// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/api/proto/vizierpb/vizierapi.proto

package vizierpb

import (
	bytes "bytes"
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type DataType int32

const (
	DATA_TYPE_UNKNOWN DataType = 0
	BOOLEAN           DataType = 1
	INT64             DataType = 2
	UINT128           DataType = 3
	FLOAT64           DataType = 4
	STRING            DataType = 5
	TIME64NS          DataType = 6
)

var DataType_name = map[int32]string{
	0: "DATA_TYPE_UNKNOWN",
	1: "BOOLEAN",
	2: "INT64",
	3: "UINT128",
	4: "FLOAT64",
	5: "STRING",
	6: "TIME64NS",
}

var DataType_value = map[string]int32{
	"DATA_TYPE_UNKNOWN": 0,
	"BOOLEAN":           1,
	"INT64":             2,
	"UINT128":           3,
	"FLOAT64":           4,
	"STRING":            5,
	"TIME64NS":          6,
}

func (DataType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{0}
}

type SemanticType int32

const (
	ST_UNSPECIFIED             SemanticType = 0
	ST_NONE                    SemanticType = 1
	ST_TIME_NS                 SemanticType = 2
	ST_AGENT_UID               SemanticType = 100
	ST_ASID                    SemanticType = 101
	ST_UPID                    SemanticType = 200
	ST_SERVICE_NAME            SemanticType = 300
	ST_POD_NAME                SemanticType = 400
	ST_POD_PHASE               SemanticType = 401
	ST_POD_STATUS              SemanticType = 402
	ST_NODE_NAME               SemanticType = 500
	ST_CONTAINER_NAME          SemanticType = 600
	ST_CONTAINER_STATE         SemanticType = 601
	ST_CONTAINER_STATUS        SemanticType = 602
	ST_NAMESPACE_NAME          SemanticType = 700
	ST_BYTES                   SemanticType = 800
	ST_PERCENT                 SemanticType = 900
	ST_DURATION_NS             SemanticType = 901
	ST_THROUGHPUT_PER_NS       SemanticType = 902
	ST_THROUGHPUT_BYTES_PER_NS SemanticType = 903
	ST_QUANTILES               SemanticType = 1000
	ST_DURATION_NS_QUANTILES   SemanticType = 1001
	ST_IP_ADDRESS              SemanticType = 1100
	ST_PORT                    SemanticType = 1200
	ST_HTTP_REQ_METHOD         SemanticType = 1300
	ST_HTTP_RESP_STATUS        SemanticType = 1400
	ST_HTTP_RESP_MESSAGE       SemanticType = 1500
	ST_SCRIPT_REFERENCE        SemanticType = 3000
)

var SemanticType_name = map[int32]string{
	0:    "ST_UNSPECIFIED",
	1:    "ST_NONE",
	2:    "ST_TIME_NS",
	100:  "ST_AGENT_UID",
	101:  "ST_ASID",
	200:  "ST_UPID",
	300:  "ST_SERVICE_NAME",
	400:  "ST_POD_NAME",
	401:  "ST_POD_PHASE",
	402:  "ST_POD_STATUS",
	500:  "ST_NODE_NAME",
	600:  "ST_CONTAINER_NAME",
	601:  "ST_CONTAINER_STATE",
	602:  "ST_CONTAINER_STATUS",
	700:  "ST_NAMESPACE_NAME",
	800:  "ST_BYTES",
	900:  "ST_PERCENT",
	901:  "ST_DURATION_NS",
	902:  "ST_THROUGHPUT_PER_NS",
	903:  "ST_THROUGHPUT_BYTES_PER_NS",
	1000: "ST_QUANTILES",
	1001: "ST_DURATION_NS_QUANTILES",
	1100: "ST_IP_ADDRESS",
	1200: "ST_PORT",
	1300: "ST_HTTP_REQ_METHOD",
	1400: "ST_HTTP_RESP_STATUS",
	1500: "ST_HTTP_RESP_MESSAGE",
	3000: "ST_SCRIPT_REFERENCE",
}

var SemanticType_value = map[string]int32{
	"ST_UNSPECIFIED":             0,
	"ST_NONE":                    1,
	"ST_TIME_NS":                 2,
	"ST_AGENT_UID":               100,
	"ST_ASID":                    101,
	"ST_UPID":                    200,
	"ST_SERVICE_NAME":            300,
	"ST_POD_NAME":                400,
	"ST_POD_PHASE":               401,
	"ST_POD_STATUS":              402,
	"ST_NODE_NAME":               500,
	"ST_CONTAINER_NAME":          600,
	"ST_CONTAINER_STATE":         601,
	"ST_CONTAINER_STATUS":        602,
	"ST_NAMESPACE_NAME":          700,
	"ST_BYTES":                   800,
	"ST_PERCENT":                 900,
	"ST_DURATION_NS":             901,
	"ST_THROUGHPUT_PER_NS":       902,
	"ST_THROUGHPUT_BYTES_PER_NS": 903,
	"ST_QUANTILES":               1000,
	"ST_DURATION_NS_QUANTILES":   1001,
	"ST_IP_ADDRESS":              1100,
	"ST_PORT":                    1200,
	"ST_HTTP_REQ_METHOD":         1300,
	"ST_HTTP_RESP_STATUS":        1400,
	"ST_HTTP_RESP_MESSAGE":       1500,
	"ST_SCRIPT_REFERENCE":        3000,
}

func (SemanticType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{1}
}

type LifeCycleState int32

const (
	UNKNOWN_STATE    LifeCycleState = 0
	PENDING_STATE    LifeCycleState = 1
	RUNNING_STATE    LifeCycleState = 2
	FAILED_STATE     LifeCycleState = 3
	TERMINATED_STATE LifeCycleState = 4
)

var LifeCycleState_name = map[int32]string{
	0: "UNKNOWN_STATE",
	1: "PENDING_STATE",
	2: "RUNNING_STATE",
	3: "FAILED_STATE",
	4: "TERMINATED_STATE",
}

var LifeCycleState_value = map[string]int32{
	"UNKNOWN_STATE":    0,
	"PENDING_STATE":    1,
	"RUNNING_STATE":    2,
	"FAILED_STATE":     3,
	"TERMINATED_STATE": 4,
}

func (LifeCycleState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{2}
}

type ContainerState int32

const (
	CONTAINER_STATE_UNKNOWN    ContainerState = 0
	CONTAINER_STATE_RUNNING    ContainerState = 1
	CONTAINER_STATE_TERMINATED ContainerState = 2
	CONTAINER_STATE_WAITING    ContainerState = 3
)

var ContainerState_name = map[int32]string{
	0: "CONTAINER_STATE_UNKNOWN",
	1: "CONTAINER_STATE_RUNNING",
	2: "CONTAINER_STATE_TERMINATED",
	3: "CONTAINER_STATE_WAITING",
}

var ContainerState_value = map[string]int32{
	"CONTAINER_STATE_UNKNOWN":    0,
	"CONTAINER_STATE_RUNNING":    1,
	"CONTAINER_STATE_TERMINATED": 2,
	"CONTAINER_STATE_WAITING":    3,
}

func (ContainerState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{3}
}

type PodPhase int32

const (
	PHASE_UNKNOWN PodPhase = 0
	PENDING       PodPhase = 1
	RUNNING       PodPhase = 2
	SUCCEEDED     PodPhase = 3
	FAILED        PodPhase = 4
)

var PodPhase_name = map[int32]string{
	0: "PHASE_UNKNOWN",
	1: "PENDING",
	2: "RUNNING",
	3: "SUCCEEDED",
	4: "FAILED",
}

var PodPhase_value = map[string]int32{
	"PHASE_UNKNOWN": 0,
	"PENDING":       1,
	"RUNNING":       2,
	"SUCCEEDED":     3,
	"FAILED":        4,
}

func (PodPhase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{4}
}

type UInt128 struct {
	Low  uint64 `protobuf:"varint,1,opt,name=low,proto3" json:"low,omitempty"`
	High uint64 `protobuf:"varint,2,opt,name=high,proto3" json:"high,omitempty"`
}

func (m *UInt128) Reset()      { *m = UInt128{} }
func (*UInt128) ProtoMessage() {}
func (*UInt128) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{0}
}
func (m *UInt128) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UInt128) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UInt128.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UInt128) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UInt128.Merge(m, src)
}
func (m *UInt128) XXX_Size() int {
	return m.Size()
}
func (m *UInt128) XXX_DiscardUnknown() {
	xxx_messageInfo_UInt128.DiscardUnknown(m)
}

var xxx_messageInfo_UInt128 proto.InternalMessageInfo

func (m *UInt128) GetLow() uint64 {
	if m != nil {
		return m.Low
	}
	return 0
}

func (m *UInt128) GetHigh() uint64 {
	if m != nil {
		return m.High
	}
	return 0
}

type BooleanColumn struct {
	Data []bool `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *BooleanColumn) Reset()      { *m = BooleanColumn{} }
func (*BooleanColumn) ProtoMessage() {}
func (*BooleanColumn) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{1}
}
func (m *BooleanColumn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BooleanColumn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BooleanColumn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BooleanColumn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BooleanColumn.Merge(m, src)
}
func (m *BooleanColumn) XXX_Size() int {
	return m.Size()
}
func (m *BooleanColumn) XXX_DiscardUnknown() {
	xxx_messageInfo_BooleanColumn.DiscardUnknown(m)
}

var xxx_messageInfo_BooleanColumn proto.InternalMessageInfo

func (m *BooleanColumn) GetData() []bool {
	if m != nil {
		return m.Data
	}
	return nil
}

type Int64Column struct {
	Data []int64 `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *Int64Column) Reset()      { *m = Int64Column{} }
func (*Int64Column) ProtoMessage() {}
func (*Int64Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{2}
}
func (m *Int64Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Int64Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Int64Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Int64Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int64Column.Merge(m, src)
}
func (m *Int64Column) XXX_Size() int {
	return m.Size()
}
func (m *Int64Column) XXX_DiscardUnknown() {
	xxx_messageInfo_Int64Column.DiscardUnknown(m)
}

var xxx_messageInfo_Int64Column proto.InternalMessageInfo

func (m *Int64Column) GetData() []int64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type UInt128Column struct {
	Data []*UInt128 `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
}

func (m *UInt128Column) Reset()      { *m = UInt128Column{} }
func (*UInt128Column) ProtoMessage() {}
func (*UInt128Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{3}
}
func (m *UInt128Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UInt128Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UInt128Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UInt128Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UInt128Column.Merge(m, src)
}
func (m *UInt128Column) XXX_Size() int {
	return m.Size()
}
func (m *UInt128Column) XXX_DiscardUnknown() {
	xxx_messageInfo_UInt128Column.DiscardUnknown(m)
}

var xxx_messageInfo_UInt128Column proto.InternalMessageInfo

func (m *UInt128Column) GetData() []*UInt128 {
	if m != nil {
		return m.Data
	}
	return nil
}

type Float64Column struct {
	Data []float64 `protobuf:"fixed64,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *Float64Column) Reset()      { *m = Float64Column{} }
func (*Float64Column) ProtoMessage() {}
func (*Float64Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{4}
}
func (m *Float64Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Float64Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Float64Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Float64Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Float64Column.Merge(m, src)
}
func (m *Float64Column) XXX_Size() int {
	return m.Size()
}
func (m *Float64Column) XXX_DiscardUnknown() {
	xxx_messageInfo_Float64Column.DiscardUnknown(m)
}

var xxx_messageInfo_Float64Column proto.InternalMessageInfo

func (m *Float64Column) GetData() []float64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type Time64NSColumn struct {
	Data []int64 `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *Time64NSColumn) Reset()      { *m = Time64NSColumn{} }
func (*Time64NSColumn) ProtoMessage() {}
func (*Time64NSColumn) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{5}
}
func (m *Time64NSColumn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Time64NSColumn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Time64NSColumn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Time64NSColumn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Time64NSColumn.Merge(m, src)
}
func (m *Time64NSColumn) XXX_Size() int {
	return m.Size()
}
func (m *Time64NSColumn) XXX_DiscardUnknown() {
	xxx_messageInfo_Time64NSColumn.DiscardUnknown(m)
}

var xxx_messageInfo_Time64NSColumn proto.InternalMessageInfo

func (m *Time64NSColumn) GetData() []int64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type StringColumn struct {
	Data [][]byte `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
}

func (m *StringColumn) Reset()      { *m = StringColumn{} }
func (*StringColumn) ProtoMessage() {}
func (*StringColumn) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{6}
}
func (m *StringColumn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StringColumn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StringColumn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StringColumn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringColumn.Merge(m, src)
}
func (m *StringColumn) XXX_Size() int {
	return m.Size()
}
func (m *StringColumn) XXX_DiscardUnknown() {
	xxx_messageInfo_StringColumn.DiscardUnknown(m)
}

var xxx_messageInfo_StringColumn proto.InternalMessageInfo

func (m *StringColumn) GetData() [][]byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type Column struct {
	// Types that are valid to be assigned to ColData:
	//
	//	*Column_BooleanData
	//	*Column_Int64Data
	//	*Column_Uint128Data
	//	*Column_Time64NsData
	//	*Column_Float64Data
	//	*Column_StringData
	ColData isColumn_ColData `protobuf_oneof:"col_data"`
}

func (m *Column) Reset()      { *m = Column{} }
func (*Column) ProtoMessage() {}
func (*Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{7}
}
func (m *Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Column.Merge(m, src)
}
func (m *Column) XXX_Size() int {
	return m.Size()
}
func (m *Column) XXX_DiscardUnknown() {
	xxx_messageInfo_Column.DiscardUnknown(m)
}

var xxx_messageInfo_Column proto.InternalMessageInfo

type isColumn_ColData interface {
	isColumn_ColData()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Column_BooleanData struct {
	BooleanData *BooleanColumn `protobuf:"bytes,1,opt,name=boolean_data,json=booleanData,proto3,oneof" json:"boolean_data,omitempty"`
}
type Column_Int64Data struct {
	Int64Data *Int64Column `protobuf:"bytes,2,opt,name=int64_data,json=int64Data,proto3,oneof" json:"int64_data,omitempty"`
}
type Column_Uint128Data struct {
	Uint128Data *UInt128Column `protobuf:"bytes,3,opt,name=uint128_data,json=uint128Data,proto3,oneof" json:"uint128_data,omitempty"`
}
type Column_Time64NsData struct {
	Time64NsData *Time64NSColumn `protobuf:"bytes,4,opt,name=time64ns_data,json=time64nsData,proto3,oneof" json:"time64ns_data,omitempty"`
}
type Column_Float64Data struct {
	Float64Data *Float64Column `protobuf:"bytes,5,opt,name=float64_data,json=float64Data,proto3,oneof" json:"float64_data,omitempty"`
}
type Column_StringData struct {
	StringData *StringColumn `protobuf:"bytes,6,opt,name=string_data,json=stringData,proto3,oneof" json:"string_data,omitempty"`
}

func (*Column_BooleanData) isColumn_ColData()  {}
func (*Column_Int64Data) isColumn_ColData()    {}
func (*Column_Uint128Data) isColumn_ColData()  {}
func (*Column_Time64NsData) isColumn_ColData() {}
func (*Column_Float64Data) isColumn_ColData()  {}
func (*Column_StringData) isColumn_ColData()   {}

func (m *Column) GetColData() isColumn_ColData {
	if m != nil {
		return m.ColData
	}
	return nil
}

func (m *Column) GetBooleanData() *BooleanColumn {
	if x, ok := m.GetColData().(*Column_BooleanData); ok {
		return x.BooleanData
	}
	return nil
}

func (m *Column) GetInt64Data() *Int64Column {
	if x, ok := m.GetColData().(*Column_Int64Data); ok {
		return x.Int64Data
	}
	return nil
}

func (m *Column) GetUint128Data() *UInt128Column {
	if x, ok := m.GetColData().(*Column_Uint128Data); ok {
		return x.Uint128Data
	}
	return nil
}

func (m *Column) GetTime64NsData() *Time64NSColumn {
	if x, ok := m.GetColData().(*Column_Time64NsData); ok {
		return x.Time64NsData
	}
	return nil
}

func (m *Column) GetFloat64Data() *Float64Column {
	if x, ok := m.GetColData().(*Column_Float64Data); ok {
		return x.Float64Data
	}
	return nil
}

func (m *Column) GetStringData() *StringColumn {
	if x, ok := m.GetColData().(*Column_StringData); ok {
		return x.StringData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Column) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Column_BooleanData)(nil),
		(*Column_Int64Data)(nil),
		(*Column_Uint128Data)(nil),
		(*Column_Time64NsData)(nil),
		(*Column_Float64Data)(nil),
		(*Column_StringData)(nil),
	}
}

type RowBatchData struct {
	TableID string    `protobuf:"bytes,5,opt,name=table_id,json=tableId,proto3" json:"table_id,omitempty"`
	Cols    []*Column `protobuf:"bytes,1,rep,name=cols,proto3" json:"cols,omitempty"`
	NumRows int64     `protobuf:"varint,2,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
	Eow     bool      `protobuf:"varint,3,opt,name=eow,proto3" json:"eow,omitempty"`
	Eos     bool      `protobuf:"varint,4,opt,name=eos,proto3" json:"eos,omitempty"`
}

func (m *RowBatchData) Reset()      { *m = RowBatchData{} }
func (*RowBatchData) ProtoMessage() {}
func (*RowBatchData) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{8}
}
func (m *RowBatchData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RowBatchData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RowBatchData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RowBatchData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RowBatchData.Merge(m, src)
}
func (m *RowBatchData) XXX_Size() int {
	return m.Size()
}
func (m *RowBatchData) XXX_DiscardUnknown() {
	xxx_messageInfo_RowBatchData.DiscardUnknown(m)
}

var xxx_messageInfo_RowBatchData proto.InternalMessageInfo

func (m *RowBatchData) GetTableID() string {
	if m != nil {
		return m.TableID
	}
	return ""
}

func (m *RowBatchData) GetCols() []*Column {
	if m != nil {
		return m.Cols
	}
	return nil
}

func (m *RowBatchData) GetNumRows() int64 {
	if m != nil {
		return m.NumRows
	}
	return 0
}

func (m *RowBatchData) GetEow() bool {
	if m != nil {
		return m.Eow
	}
	return false
}

func (m *RowBatchData) GetEos() bool {
	if m != nil {
		return m.Eos
	}
	return false
}

type Relation struct {
	Columns []*Relation_ColumnInfo `protobuf:"bytes,1,rep,name=columns,proto3" json:"columns,omitempty"`
}

func (m *Relation) Reset()      { *m = Relation{} }
func (*Relation) ProtoMessage() {}
func (*Relation) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{9}
}
func (m *Relation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Relation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Relation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Relation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Relation.Merge(m, src)
}
func (m *Relation) XXX_Size() int {
	return m.Size()
}
func (m *Relation) XXX_DiscardUnknown() {
	xxx_messageInfo_Relation.DiscardUnknown(m)
}

var xxx_messageInfo_Relation proto.InternalMessageInfo

func (m *Relation) GetColumns() []*Relation_ColumnInfo {
	if m != nil {
		return m.Columns
	}
	return nil
}

type Relation_ColumnInfo struct {
	ColumnName         string       `protobuf:"bytes,1,opt,name=column_name,json=columnName,proto3" json:"column_name,omitempty"`
	ColumnType         DataType     `protobuf:"varint,2,opt,name=column_type,json=columnType,proto3,enum=px.api.vizierpb.DataType" json:"column_type,omitempty"`
	ColumnDesc         string       `protobuf:"bytes,3,opt,name=column_desc,json=columnDesc,proto3" json:"column_desc,omitempty"`
	ColumnSemanticType SemanticType `protobuf:"varint,4,opt,name=column_semantic_type,json=columnSemanticType,proto3,enum=px.api.vizierpb.SemanticType" json:"column_semantic_type,omitempty"`
}

func (m *Relation_ColumnInfo) Reset()      { *m = Relation_ColumnInfo{} }
func (*Relation_ColumnInfo) ProtoMessage() {}
func (*Relation_ColumnInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{9, 0}
}
func (m *Relation_ColumnInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Relation_ColumnInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Relation_ColumnInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Relation_ColumnInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Relation_ColumnInfo.Merge(m, src)
}
func (m *Relation_ColumnInfo) XXX_Size() int {
	return m.Size()
}
func (m *Relation_ColumnInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_Relation_ColumnInfo.DiscardUnknown(m)
}

var xxx_messageInfo_Relation_ColumnInfo proto.InternalMessageInfo

func (m *Relation_ColumnInfo) GetColumnName() string {
	if m != nil {
		return m.ColumnName
	}
	return ""
}

func (m *Relation_ColumnInfo) GetColumnType() DataType {
	if m != nil {
		return m.ColumnType
	}
	return DATA_TYPE_UNKNOWN
}

func (m *Relation_ColumnInfo) GetColumnDesc() string {
	if m != nil {
		return m.ColumnDesc
	}
	return ""
}

func (m *Relation_ColumnInfo) GetColumnSemanticType() SemanticType {
	if m != nil {
		return m.ColumnSemanticType
	}
	return ST_UNSPECIFIED
}

type CompilerError struct {
	Line    uint64 `protobuf:"varint,1,opt,name=line,proto3" json:"line,omitempty"`
	Column  uint64 `protobuf:"varint,2,opt,name=column,proto3" json:"column,omitempty"`
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *CompilerError) Reset()      { *m = CompilerError{} }
func (*CompilerError) ProtoMessage() {}
func (*CompilerError) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{10}
}
func (m *CompilerError) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompilerError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompilerError.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CompilerError) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompilerError.Merge(m, src)
}
func (m *CompilerError) XXX_Size() int {
	return m.Size()
}
func (m *CompilerError) XXX_DiscardUnknown() {
	xxx_messageInfo_CompilerError.DiscardUnknown(m)
}

var xxx_messageInfo_CompilerError proto.InternalMessageInfo

func (m *CompilerError) GetLine() uint64 {
	if m != nil {
		return m.Line
	}
	return 0
}

func (m *CompilerError) GetColumn() uint64 {
	if m != nil {
		return m.Column
	}
	return 0
}

func (m *CompilerError) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type ErrorDetails struct {
	// Types that are valid to be assigned to Error:
	//
	//	*ErrorDetails_CompilerError
	Error isErrorDetails_Error `protobuf_oneof:"error"`
}

func (m *ErrorDetails) Reset()      { *m = ErrorDetails{} }
func (*ErrorDetails) ProtoMessage() {}
func (*ErrorDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{11}
}
func (m *ErrorDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ErrorDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ErrorDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ErrorDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ErrorDetails.Merge(m, src)
}
func (m *ErrorDetails) XXX_Size() int {
	return m.Size()
}
func (m *ErrorDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_ErrorDetails.DiscardUnknown(m)
}

var xxx_messageInfo_ErrorDetails proto.InternalMessageInfo

type isErrorDetails_Error interface {
	isErrorDetails_Error()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ErrorDetails_CompilerError struct {
	CompilerError *CompilerError `protobuf:"bytes,1,opt,name=compiler_error,json=compilerError,proto3,oneof" json:"compiler_error,omitempty"`
}

func (*ErrorDetails_CompilerError) isErrorDetails_Error() {}

func (m *ErrorDetails) GetError() isErrorDetails_Error {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *ErrorDetails) GetCompilerError() *CompilerError {
	if x, ok := m.GetError().(*ErrorDetails_CompilerError); ok {
		return x.CompilerError
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ErrorDetails) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ErrorDetails_CompilerError)(nil),
	}
}

type Status struct {
	Code         int32           `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	Message      string          `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	ErrorDetails []*ErrorDetails `protobuf:"bytes,4,rep,name=error_details,json=errorDetails,proto3" json:"error_details,omitempty"`
}

func (m *Status) Reset()      { *m = Status{} }
func (*Status) ProtoMessage() {}
func (*Status) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{12}
}
func (m *Status) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Status.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Status) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Status.Merge(m, src)
}
func (m *Status) XXX_Size() int {
	return m.Size()
}
func (m *Status) XXX_DiscardUnknown() {
	xxx_messageInfo_Status.DiscardUnknown(m)
}

var xxx_messageInfo_Status proto.InternalMessageInfo

func (m *Status) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *Status) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *Status) GetErrorDetails() []*ErrorDetails {
	if m != nil {
		return m.ErrorDetails
	}
	return nil
}

type ScalarValue struct {
	DataType DataType `protobuf:"varint,1,opt,name=data_type,json=dataType,proto3,enum=px.api.vizierpb.DataType" json:"data_type,omitempty"`
	// Types that are valid to be assigned to Value:
	//
	//	*ScalarValue_BoolValue
	//	*ScalarValue_Int64Value
	//	*ScalarValue_Float64Value
	//	*ScalarValue_StringValue
	//	*ScalarValue_Time64NsValue
	//	*ScalarValue_Uint128Value
	Value isScalarValue_Value `protobuf_oneof:"value"`
}

func (m *ScalarValue) Reset()      { *m = ScalarValue{} }
func (*ScalarValue) ProtoMessage() {}
func (*ScalarValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{13}
}
func (m *ScalarValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScalarValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ScalarValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ScalarValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScalarValue.Merge(m, src)
}
func (m *ScalarValue) XXX_Size() int {
	return m.Size()
}
func (m *ScalarValue) XXX_DiscardUnknown() {
	xxx_messageInfo_ScalarValue.DiscardUnknown(m)
}

var xxx_messageInfo_ScalarValue proto.InternalMessageInfo

type isScalarValue_Value interface {
	isScalarValue_Value()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ScalarValue_BoolValue struct {
	BoolValue bool `protobuf:"varint,2,opt,name=bool_value,json=boolValue,proto3,oneof" json:"bool_value,omitempty"`
}
type ScalarValue_Int64Value struct {
	Int64Value int64 `protobuf:"varint,3,opt,name=int64_value,json=int64Value,proto3,oneof" json:"int64_value,omitempty"`
}
type ScalarValue_Float64Value struct {
	Float64Value float64 `protobuf:"fixed64,4,opt,name=float64_value,json=float64Value,proto3,oneof" json:"float64_value,omitempty"`
}
type ScalarValue_StringValue struct {
	StringValue string `protobuf:"bytes,5,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
}
type ScalarValue_Time64NsValue struct {
	Time64NsValue int64 `protobuf:"varint,6,opt,name=time64_ns_value,json=time64NsValue,proto3,oneof" json:"time64_ns_value,omitempty"`
}
type ScalarValue_Uint128Value struct {
	Uint128Value *UInt128 `protobuf:"bytes,7,opt,name=uint128_value,json=uint128Value,proto3,oneof" json:"uint128_value,omitempty"`
}

func (*ScalarValue_BoolValue) isScalarValue_Value()     {}
func (*ScalarValue_Int64Value) isScalarValue_Value()    {}
func (*ScalarValue_Float64Value) isScalarValue_Value()  {}
func (*ScalarValue_StringValue) isScalarValue_Value()   {}
func (*ScalarValue_Time64NsValue) isScalarValue_Value() {}
func (*ScalarValue_Uint128Value) isScalarValue_Value()  {}

func (m *ScalarValue) GetValue() isScalarValue_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *ScalarValue) GetDataType() DataType {
	if m != nil {
		return m.DataType
	}
	return DATA_TYPE_UNKNOWN
}

func (m *ScalarValue) GetBoolValue() bool {
	if x, ok := m.GetValue().(*ScalarValue_BoolValue); ok {
		return x.BoolValue
	}
	return false
}

func (m *ScalarValue) GetInt64Value() int64 {
	if x, ok := m.GetValue().(*ScalarValue_Int64Value); ok {
		return x.Int64Value
	}
	return 0
}

func (m *ScalarValue) GetFloat64Value() float64 {
	if x, ok := m.GetValue().(*ScalarValue_Float64Value); ok {
		return x.Float64Value
	}
	return 0
}

func (m *ScalarValue) GetStringValue() string {
	if x, ok := m.GetValue().(*ScalarValue_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *ScalarValue) GetTime64NsValue() int64 {
	if x, ok := m.GetValue().(*ScalarValue_Time64NsValue); ok {
		return x.Time64NsValue
	}
	return 0
}

func (m *ScalarValue) GetUint128Value() *UInt128 {
	if x, ok := m.GetValue().(*ScalarValue_Uint128Value); ok {
		return x.Uint128Value
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ScalarValue) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ScalarValue_BoolValue)(nil),
		(*ScalarValue_Int64Value)(nil),
		(*ScalarValue_Float64Value)(nil),
		(*ScalarValue_StringValue)(nil),
		(*ScalarValue_Time64NsValue)(nil),
		(*ScalarValue_Uint128Value)(nil),
	}
}

type ExecuteScriptRequest struct {
	QueryStr          string                                  `protobuf:"bytes,1,opt,name=query_str,json=queryStr,proto3" json:"query_str,omitempty"`
	ClusterID         string                                  `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	ExecFuncs         []*ExecuteScriptRequest_FuncToExecute   `protobuf:"bytes,4,rep,name=exec_funcs,json=execFuncs,proto3" json:"exec_funcs,omitempty"`
	Mutation          bool                                    `protobuf:"varint,5,opt,name=mutation,proto3" json:"mutation,omitempty"`
	EncryptionOptions *ExecuteScriptRequest_EncryptionOptions `protobuf:"bytes,6,opt,name=encryption_options,json=encryptionOptions,proto3" json:"encryption_options,omitempty"`
	QueryID           string                                  `protobuf:"bytes,7,opt,name=query_id,json=queryId,proto3" json:"query_id,omitempty"`
	Configs           *Configs                                `protobuf:"bytes,9,opt,name=configs,proto3" json:"configs,omitempty"`
	QueryName         string                                  `protobuf:"bytes,10,opt,name=query_name,json=queryName,proto3" json:"query_name,omitempty"`
}

func (m *ExecuteScriptRequest) Reset()      { *m = ExecuteScriptRequest{} }
func (*ExecuteScriptRequest) ProtoMessage() {}
func (*ExecuteScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{14}
}
func (m *ExecuteScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecuteScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecuteScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecuteScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteScriptRequest.Merge(m, src)
}
func (m *ExecuteScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExecuteScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteScriptRequest proto.InternalMessageInfo

func (m *ExecuteScriptRequest) GetQueryStr() string {
	if m != nil {
		return m.QueryStr
	}
	return ""
}

func (m *ExecuteScriptRequest) GetClusterID() string {
	if m != nil {
		return m.ClusterID
	}
	return ""
}

func (m *ExecuteScriptRequest) GetExecFuncs() []*ExecuteScriptRequest_FuncToExecute {
	if m != nil {
		return m.ExecFuncs
	}
	return nil
}

func (m *ExecuteScriptRequest) GetMutation() bool {
	if m != nil {
		return m.Mutation
	}
	return false
}

func (m *ExecuteScriptRequest) GetEncryptionOptions() *ExecuteScriptRequest_EncryptionOptions {
	if m != nil {
		return m.EncryptionOptions
	}
	return nil
}

func (m *ExecuteScriptRequest) GetQueryID() string {
	if m != nil {
		return m.QueryID
	}
	return ""
}

func (m *ExecuteScriptRequest) GetConfigs() *Configs {
	if m != nil {
		return m.Configs
	}
	return nil
}

func (m *ExecuteScriptRequest) GetQueryName() string {
	if m != nil {
		return m.QueryName
	}
	return ""
}

type ExecuteScriptRequest_FuncToExecute struct {
	FuncName          string                                         `protobuf:"bytes,1,opt,name=func_name,json=funcName,proto3" json:"func_name,omitempty"`
	ArgValues         []*ExecuteScriptRequest_FuncToExecute_ArgValue `protobuf:"bytes,2,rep,name=arg_values,json=argValues,proto3" json:"arg_values,omitempty"`
	OutputTablePrefix string                                         `protobuf:"bytes,3,opt,name=output_table_prefix,json=outputTablePrefix,proto3" json:"output_table_prefix,omitempty"`
}

func (m *ExecuteScriptRequest_FuncToExecute) Reset()      { *m = ExecuteScriptRequest_FuncToExecute{} }
func (*ExecuteScriptRequest_FuncToExecute) ProtoMessage() {}
func (*ExecuteScriptRequest_FuncToExecute) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{14, 0}
}
func (m *ExecuteScriptRequest_FuncToExecute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecuteScriptRequest_FuncToExecute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecuteScriptRequest_FuncToExecute.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecuteScriptRequest_FuncToExecute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteScriptRequest_FuncToExecute.Merge(m, src)
}
func (m *ExecuteScriptRequest_FuncToExecute) XXX_Size() int {
	return m.Size()
}
func (m *ExecuteScriptRequest_FuncToExecute) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteScriptRequest_FuncToExecute.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteScriptRequest_FuncToExecute proto.InternalMessageInfo

func (m *ExecuteScriptRequest_FuncToExecute) GetFuncName() string {
	if m != nil {
		return m.FuncName
	}
	return ""
}

func (m *ExecuteScriptRequest_FuncToExecute) GetArgValues() []*ExecuteScriptRequest_FuncToExecute_ArgValue {
	if m != nil {
		return m.ArgValues
	}
	return nil
}

func (m *ExecuteScriptRequest_FuncToExecute) GetOutputTablePrefix() string {
	if m != nil {
		return m.OutputTablePrefix
	}
	return ""
}

type ExecuteScriptRequest_FuncToExecute_ArgValue struct {
	Name  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) Reset() {
	*m = ExecuteScriptRequest_FuncToExecute_ArgValue{}
}
func (*ExecuteScriptRequest_FuncToExecute_ArgValue) ProtoMessage() {}
func (*ExecuteScriptRequest_FuncToExecute_ArgValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{14, 0, 0}
}
func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecuteScriptRequest_FuncToExecute_ArgValue.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteScriptRequest_FuncToExecute_ArgValue.Merge(m, src)
}
func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) XXX_Size() int {
	return m.Size()
}
func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteScriptRequest_FuncToExecute_ArgValue.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteScriptRequest_FuncToExecute_ArgValue proto.InternalMessageInfo

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type ExecuteScriptRequest_EncryptionOptions struct {
	JwkKey         string `protobuf:"bytes,1,opt,name=jwk_key,json=jwkKey,proto3" json:"jwk_key,omitempty"`
	KeyAlg         string `protobuf:"bytes,2,opt,name=key_alg,json=keyAlg,proto3" json:"key_alg,omitempty"`
	ContentAlg     string `protobuf:"bytes,3,opt,name=content_alg,json=contentAlg,proto3" json:"content_alg,omitempty"`
	CompressionAlg string `protobuf:"bytes,4,opt,name=compression_alg,json=compressionAlg,proto3" json:"compression_alg,omitempty"`
}

func (m *ExecuteScriptRequest_EncryptionOptions) Reset() {
	*m = ExecuteScriptRequest_EncryptionOptions{}
}
func (*ExecuteScriptRequest_EncryptionOptions) ProtoMessage() {}
func (*ExecuteScriptRequest_EncryptionOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{14, 1}
}
func (m *ExecuteScriptRequest_EncryptionOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecuteScriptRequest_EncryptionOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecuteScriptRequest_EncryptionOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecuteScriptRequest_EncryptionOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteScriptRequest_EncryptionOptions.Merge(m, src)
}
func (m *ExecuteScriptRequest_EncryptionOptions) XXX_Size() int {
	return m.Size()
}
func (m *ExecuteScriptRequest_EncryptionOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteScriptRequest_EncryptionOptions.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteScriptRequest_EncryptionOptions proto.InternalMessageInfo

func (m *ExecuteScriptRequest_EncryptionOptions) GetJwkKey() string {
	if m != nil {
		return m.JwkKey
	}
	return ""
}

func (m *ExecuteScriptRequest_EncryptionOptions) GetKeyAlg() string {
	if m != nil {
		return m.KeyAlg
	}
	return ""
}

func (m *ExecuteScriptRequest_EncryptionOptions) GetContentAlg() string {
	if m != nil {
		return m.ContentAlg
	}
	return ""
}

func (m *ExecuteScriptRequest_EncryptionOptions) GetCompressionAlg() string {
	if m != nil {
		return m.CompressionAlg
	}
	return ""
}

type Configs struct {
	OTelEndpointConfig *Configs_OTelEndpointConfig `protobuf:"bytes,1,opt,name=otel_endpoint_config,json=otelEndpointConfig,proto3" json:"otel_endpoint_config,omitempty"`
	PluginConfig       *Configs_PluginConfig       `protobuf:"bytes,2,opt,name=plugin_config,json=pluginConfig,proto3" json:"plugin_config,omitempty"`
}

func (m *Configs) Reset()      { *m = Configs{} }
func (*Configs) ProtoMessage() {}
func (*Configs) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{15}
}
func (m *Configs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Configs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Configs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Configs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configs.Merge(m, src)
}
func (m *Configs) XXX_Size() int {
	return m.Size()
}
func (m *Configs) XXX_DiscardUnknown() {
	xxx_messageInfo_Configs.DiscardUnknown(m)
}

var xxx_messageInfo_Configs proto.InternalMessageInfo

func (m *Configs) GetOTelEndpointConfig() *Configs_OTelEndpointConfig {
	if m != nil {
		return m.OTelEndpointConfig
	}
	return nil
}

func (m *Configs) GetPluginConfig() *Configs_PluginConfig {
	if m != nil {
		return m.PluginConfig
	}
	return nil
}

type Configs_OTelEndpointConfig struct {
	URL      string            `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Headers  map[string]string `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Insecure bool              `protobuf:"varint,3,opt,name=insecure,proto3" json:"insecure,omitempty"`
	Timeout  int64             `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
}

func (m *Configs_OTelEndpointConfig) Reset()      { *m = Configs_OTelEndpointConfig{} }
func (*Configs_OTelEndpointConfig) ProtoMessage() {}
func (*Configs_OTelEndpointConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{15, 0}
}
func (m *Configs_OTelEndpointConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Configs_OTelEndpointConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Configs_OTelEndpointConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Configs_OTelEndpointConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configs_OTelEndpointConfig.Merge(m, src)
}
func (m *Configs_OTelEndpointConfig) XXX_Size() int {
	return m.Size()
}
func (m *Configs_OTelEndpointConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Configs_OTelEndpointConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Configs_OTelEndpointConfig proto.InternalMessageInfo

func (m *Configs_OTelEndpointConfig) GetURL() string {
	if m != nil {
		return m.URL
	}
	return ""
}

func (m *Configs_OTelEndpointConfig) GetHeaders() map[string]string {
	if m != nil {
		return m.Headers
	}
	return nil
}

func (m *Configs_OTelEndpointConfig) GetInsecure() bool {
	if m != nil {
		return m.Insecure
	}
	return false
}

func (m *Configs_OTelEndpointConfig) GetTimeout() int64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

type Configs_PluginConfig struct {
	StartTimeNs int64 `protobuf:"varint,1,opt,name=start_time_ns,json=startTimeNs,proto3" json:"start_time_ns,omitempty"`
	EndTimeNs   int64 `protobuf:"varint,2,opt,name=end_time_ns,json=endTimeNs,proto3" json:"end_time_ns,omitempty"`
}

func (m *Configs_PluginConfig) Reset()      { *m = Configs_PluginConfig{} }
func (*Configs_PluginConfig) ProtoMessage() {}
func (*Configs_PluginConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{15, 1}
}
func (m *Configs_PluginConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Configs_PluginConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Configs_PluginConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Configs_PluginConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configs_PluginConfig.Merge(m, src)
}
func (m *Configs_PluginConfig) XXX_Size() int {
	return m.Size()
}
func (m *Configs_PluginConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_Configs_PluginConfig.DiscardUnknown(m)
}

var xxx_messageInfo_Configs_PluginConfig proto.InternalMessageInfo

func (m *Configs_PluginConfig) GetStartTimeNs() int64 {
	if m != nil {
		return m.StartTimeNs
	}
	return 0
}

func (m *Configs_PluginConfig) GetEndTimeNs() int64 {
	if m != nil {
		return m.EndTimeNs
	}
	return 0
}

type QueryTimingInfo struct {
	ExecutionTimeNs   int64 `protobuf:"varint,1,opt,name=execution_time_ns,json=executionTimeNs,proto3" json:"execution_time_ns,omitempty"`
	CompilationTimeNs int64 `protobuf:"varint,2,opt,name=compilation_time_ns,json=compilationTimeNs,proto3" json:"compilation_time_ns,omitempty"`
}

func (m *QueryTimingInfo) Reset()      { *m = QueryTimingInfo{} }
func (*QueryTimingInfo) ProtoMessage() {}
func (*QueryTimingInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{16}
}
func (m *QueryTimingInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryTimingInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryTimingInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryTimingInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryTimingInfo.Merge(m, src)
}
func (m *QueryTimingInfo) XXX_Size() int {
	return m.Size()
}
func (m *QueryTimingInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryTimingInfo.DiscardUnknown(m)
}

var xxx_messageInfo_QueryTimingInfo proto.InternalMessageInfo

func (m *QueryTimingInfo) GetExecutionTimeNs() int64 {
	if m != nil {
		return m.ExecutionTimeNs
	}
	return 0
}

func (m *QueryTimingInfo) GetCompilationTimeNs() int64 {
	if m != nil {
		return m.CompilationTimeNs
	}
	return 0
}

type QueryExecutionStats struct {
	Timing           *QueryTimingInfo `protobuf:"bytes,1,opt,name=timing,proto3" json:"timing,omitempty"`
	BytesProcessed   int64            `protobuf:"varint,2,opt,name=bytes_processed,json=bytesProcessed,proto3" json:"bytes_processed,omitempty"`
	RecordsProcessed int64            `protobuf:"varint,3,opt,name=records_processed,json=recordsProcessed,proto3" json:"records_processed,omitempty"`
}

func (m *QueryExecutionStats) Reset()      { *m = QueryExecutionStats{} }
func (*QueryExecutionStats) ProtoMessage() {}
func (*QueryExecutionStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{17}
}
func (m *QueryExecutionStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryExecutionStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryExecutionStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryExecutionStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryExecutionStats.Merge(m, src)
}
func (m *QueryExecutionStats) XXX_Size() int {
	return m.Size()
}
func (m *QueryExecutionStats) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryExecutionStats.DiscardUnknown(m)
}

var xxx_messageInfo_QueryExecutionStats proto.InternalMessageInfo

func (m *QueryExecutionStats) GetTiming() *QueryTimingInfo {
	if m != nil {
		return m.Timing
	}
	return nil
}

func (m *QueryExecutionStats) GetBytesProcessed() int64 {
	if m != nil {
		return m.BytesProcessed
	}
	return 0
}

func (m *QueryExecutionStats) GetRecordsProcessed() int64 {
	if m != nil {
		return m.RecordsProcessed
	}
	return 0
}

type QueryMetadata struct {
	Relation *Relation `protobuf:"bytes,1,opt,name=relation,proto3" json:"relation,omitempty"`
	Name     string    `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	ID       string    `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *QueryMetadata) Reset()      { *m = QueryMetadata{} }
func (*QueryMetadata) ProtoMessage() {}
func (*QueryMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{18}
}
func (m *QueryMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryMetadata.Merge(m, src)
}
func (m *QueryMetadata) XXX_Size() int {
	return m.Size()
}
func (m *QueryMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_QueryMetadata proto.InternalMessageInfo

func (m *QueryMetadata) GetRelation() *Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

func (m *QueryMetadata) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *QueryMetadata) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

type QueryData struct {
	Batch          *RowBatchData        `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"`
	EncryptedBatch []byte               `protobuf:"bytes,3,opt,name=encrypted_batch,json=encryptedBatch,proto3" json:"encrypted_batch,omitempty"`
	ExecutionStats *QueryExecutionStats `protobuf:"bytes,2,opt,name=execution_stats,json=executionStats,proto3" json:"execution_stats,omitempty"`
}

func (m *QueryData) Reset()      { *m = QueryData{} }
func (*QueryData) ProtoMessage() {}
func (*QueryData) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{19}
}
func (m *QueryData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryData.Merge(m, src)
}
func (m *QueryData) XXX_Size() int {
	return m.Size()
}
func (m *QueryData) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryData.DiscardUnknown(m)
}

var xxx_messageInfo_QueryData proto.InternalMessageInfo

func (m *QueryData) GetBatch() *RowBatchData {
	if m != nil {
		return m.Batch
	}
	return nil
}

func (m *QueryData) GetEncryptedBatch() []byte {
	if m != nil {
		return m.EncryptedBatch
	}
	return nil
}

func (m *QueryData) GetExecutionStats() *QueryExecutionStats {
	if m != nil {
		return m.ExecutionStats
	}
	return nil
}

type ExecuteScriptResponse struct {
	Status  *Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	QueryID string  `protobuf:"bytes,2,opt,name=query_id,json=queryId,proto3" json:"query_id,omitempty"`
	// Types that are valid to be assigned to Result:
	//
	//	*ExecuteScriptResponse_Data
	//	*ExecuteScriptResponse_MetaData
	Result       isExecuteScriptResponse_Result `protobuf_oneof:"result"`
	MutationInfo *MutationInfo                  `protobuf:"bytes,5,opt,name=mutation_info,json=mutationInfo,proto3" json:"mutation_info,omitempty"`
}

func (m *ExecuteScriptResponse) Reset()      { *m = ExecuteScriptResponse{} }
func (*ExecuteScriptResponse) ProtoMessage() {}
func (*ExecuteScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{20}
}
func (m *ExecuteScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecuteScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecuteScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExecuteScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteScriptResponse.Merge(m, src)
}
func (m *ExecuteScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *ExecuteScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteScriptResponse proto.InternalMessageInfo

type isExecuteScriptResponse_Result interface {
	isExecuteScriptResponse_Result()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type ExecuteScriptResponse_Data struct {
	Data *QueryData `protobuf:"bytes,3,opt,name=data,proto3,oneof" json:"data,omitempty"`
}
type ExecuteScriptResponse_MetaData struct {
	MetaData *QueryMetadata `protobuf:"bytes,4,opt,name=meta_data,json=metaData,proto3,oneof" json:"meta_data,omitempty"`
}

func (*ExecuteScriptResponse_Data) isExecuteScriptResponse_Result()     {}
func (*ExecuteScriptResponse_MetaData) isExecuteScriptResponse_Result() {}

func (m *ExecuteScriptResponse) GetResult() isExecuteScriptResponse_Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *ExecuteScriptResponse) GetStatus() *Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ExecuteScriptResponse) GetQueryID() string {
	if m != nil {
		return m.QueryID
	}
	return ""
}

func (m *ExecuteScriptResponse) GetData() *QueryData {
	if x, ok := m.GetResult().(*ExecuteScriptResponse_Data); ok {
		return x.Data
	}
	return nil
}

func (m *ExecuteScriptResponse) GetMetaData() *QueryMetadata {
	if x, ok := m.GetResult().(*ExecuteScriptResponse_MetaData); ok {
		return x.MetaData
	}
	return nil
}

func (m *ExecuteScriptResponse) GetMutationInfo() *MutationInfo {
	if m != nil {
		return m.MutationInfo
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ExecuteScriptResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ExecuteScriptResponse_Data)(nil),
		(*ExecuteScriptResponse_MetaData)(nil),
	}
}

type MutationInfo struct {
	Status *Status                       `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	States []*MutationInfo_MutationState `protobuf:"bytes,2,rep,name=states,proto3" json:"states,omitempty"`
}

func (m *MutationInfo) Reset()      { *m = MutationInfo{} }
func (*MutationInfo) ProtoMessage() {}
func (*MutationInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{21}
}
func (m *MutationInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MutationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MutationInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MutationInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MutationInfo.Merge(m, src)
}
func (m *MutationInfo) XXX_Size() int {
	return m.Size()
}
func (m *MutationInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_MutationInfo.DiscardUnknown(m)
}

var xxx_messageInfo_MutationInfo proto.InternalMessageInfo

func (m *MutationInfo) GetStatus() *Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *MutationInfo) GetStates() []*MutationInfo_MutationState {
	if m != nil {
		return m.States
	}
	return nil
}

type MutationInfo_MutationState struct {
	ID    string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	State LifeCycleState `protobuf:"varint,2,opt,name=state,proto3,enum=px.api.vizierpb.LifeCycleState" json:"state,omitempty"`
	Name  string         `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *MutationInfo_MutationState) Reset()      { *m = MutationInfo_MutationState{} }
func (*MutationInfo_MutationState) ProtoMessage() {}
func (*MutationInfo_MutationState) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{21, 0}
}
func (m *MutationInfo_MutationState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MutationInfo_MutationState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MutationInfo_MutationState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MutationInfo_MutationState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MutationInfo_MutationState.Merge(m, src)
}
func (m *MutationInfo_MutationState) XXX_Size() int {
	return m.Size()
}
func (m *MutationInfo_MutationState) XXX_DiscardUnknown() {
	xxx_messageInfo_MutationInfo_MutationState.DiscardUnknown(m)
}

var xxx_messageInfo_MutationInfo_MutationState proto.InternalMessageInfo

func (m *MutationInfo_MutationState) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *MutationInfo_MutationState) GetState() LifeCycleState {
	if m != nil {
		return m.State
	}
	return UNKNOWN_STATE
}

func (m *MutationInfo_MutationState) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type HealthCheckRequest struct {
	ClusterID string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
}

func (m *HealthCheckRequest) Reset()      { *m = HealthCheckRequest{} }
func (*HealthCheckRequest) ProtoMessage() {}
func (*HealthCheckRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{22}
}
func (m *HealthCheckRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HealthCheckRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HealthCheckRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HealthCheckRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HealthCheckRequest.Merge(m, src)
}
func (m *HealthCheckRequest) XXX_Size() int {
	return m.Size()
}
func (m *HealthCheckRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HealthCheckRequest.DiscardUnknown(m)
}

var xxx_messageInfo_HealthCheckRequest proto.InternalMessageInfo

func (m *HealthCheckRequest) GetClusterID() string {
	if m != nil {
		return m.ClusterID
	}
	return ""
}

type HealthCheckResponse struct {
	Status *Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *HealthCheckResponse) Reset()      { *m = HealthCheckResponse{} }
func (*HealthCheckResponse) ProtoMessage() {}
func (*HealthCheckResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{23}
}
func (m *HealthCheckResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HealthCheckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HealthCheckResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *HealthCheckResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HealthCheckResponse.Merge(m, src)
}
func (m *HealthCheckResponse) XXX_Size() int {
	return m.Size()
}
func (m *HealthCheckResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_HealthCheckResponse.DiscardUnknown(m)
}

var xxx_messageInfo_HealthCheckResponse proto.InternalMessageInfo

func (m *HealthCheckResponse) GetStatus() *Status {
	if m != nil {
		return m.Status
	}
	return nil
}

type GenerateOTelScriptRequest struct {
	ClusterID string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	PxlScript string `protobuf:"bytes,2,opt,name=pxl_script,json=pxlScript,proto3" json:"pxl_script,omitempty"`
}

func (m *GenerateOTelScriptRequest) Reset()      { *m = GenerateOTelScriptRequest{} }
func (*GenerateOTelScriptRequest) ProtoMessage() {}
func (*GenerateOTelScriptRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{24}
}
func (m *GenerateOTelScriptRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GenerateOTelScriptRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GenerateOTelScriptRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GenerateOTelScriptRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenerateOTelScriptRequest.Merge(m, src)
}
func (m *GenerateOTelScriptRequest) XXX_Size() int {
	return m.Size()
}
func (m *GenerateOTelScriptRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GenerateOTelScriptRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GenerateOTelScriptRequest proto.InternalMessageInfo

func (m *GenerateOTelScriptRequest) GetClusterID() string {
	if m != nil {
		return m.ClusterID
	}
	return ""
}

func (m *GenerateOTelScriptRequest) GetPxlScript() string {
	if m != nil {
		return m.PxlScript
	}
	return ""
}

type GenerateOTelScriptResponse struct {
	Status     *Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	OTelScript string  `protobuf:"bytes,2,opt,name=otel_script,json=otelScript,proto3" json:"otel_script,omitempty"`
}

func (m *GenerateOTelScriptResponse) Reset()      { *m = GenerateOTelScriptResponse{} }
func (*GenerateOTelScriptResponse) ProtoMessage() {}
func (*GenerateOTelScriptResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{25}
}
func (m *GenerateOTelScriptResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GenerateOTelScriptResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GenerateOTelScriptResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GenerateOTelScriptResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenerateOTelScriptResponse.Merge(m, src)
}
func (m *GenerateOTelScriptResponse) XXX_Size() int {
	return m.Size()
}
func (m *GenerateOTelScriptResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GenerateOTelScriptResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GenerateOTelScriptResponse proto.InternalMessageInfo

func (m *GenerateOTelScriptResponse) GetStatus() *Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *GenerateOTelScriptResponse) GetOTelScript() string {
	if m != nil {
		return m.OTelScript
	}
	return ""
}

type DebugLogRequest struct {
	ClusterID string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	PodName   string `protobuf:"bytes,2,opt,name=pod_name,json=podName,proto3" json:"pod_name,omitempty"`
	Previous  bool   `protobuf:"varint,3,opt,name=previous,proto3" json:"previous,omitempty"`
	Container string `protobuf:"bytes,4,opt,name=container,proto3" json:"container,omitempty"`
}

func (m *DebugLogRequest) Reset()      { *m = DebugLogRequest{} }
func (*DebugLogRequest) ProtoMessage() {}
func (*DebugLogRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{26}
}
func (m *DebugLogRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DebugLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DebugLogRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DebugLogRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugLogRequest.Merge(m, src)
}
func (m *DebugLogRequest) XXX_Size() int {
	return m.Size()
}
func (m *DebugLogRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugLogRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DebugLogRequest proto.InternalMessageInfo

func (m *DebugLogRequest) GetClusterID() string {
	if m != nil {
		return m.ClusterID
	}
	return ""
}

func (m *DebugLogRequest) GetPodName() string {
	if m != nil {
		return m.PodName
	}
	return ""
}

func (m *DebugLogRequest) GetPrevious() bool {
	if m != nil {
		return m.Previous
	}
	return false
}

func (m *DebugLogRequest) GetContainer() string {
	if m != nil {
		return m.Container
	}
	return ""
}

type DebugLogResponse struct {
	Data string `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *DebugLogResponse) Reset()      { *m = DebugLogResponse{} }
func (*DebugLogResponse) ProtoMessage() {}
func (*DebugLogResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{27}
}
func (m *DebugLogResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DebugLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DebugLogResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DebugLogResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugLogResponse.Merge(m, src)
}
func (m *DebugLogResponse) XXX_Size() int {
	return m.Size()
}
func (m *DebugLogResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugLogResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DebugLogResponse proto.InternalMessageInfo

func (m *DebugLogResponse) GetData() string {
	if m != nil {
		return m.Data
	}
	return ""
}

type ContainerStatus struct {
	Name             string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ContainerState   ContainerState `protobuf:"varint,2,opt,name=container_state,json=containerState,proto3,enum=px.api.vizierpb.ContainerState" json:"container_state,omitempty"`
	Message          string         `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Reason           string         `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"`
	StartTimestampNS int64          `protobuf:"varint,5,opt,name=start_timestamp_ns,json=startTimestampNs,proto3" json:"start_timestamp_ns,omitempty"`
	RestartCount     int64          `protobuf:"varint,6,opt,name=restart_count,json=restartCount,proto3" json:"restart_count,omitempty"`
}

func (m *ContainerStatus) Reset()      { *m = ContainerStatus{} }
func (*ContainerStatus) ProtoMessage() {}
func (*ContainerStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{28}
}
func (m *ContainerStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContainerStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContainerStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainerStatus.Merge(m, src)
}
func (m *ContainerStatus) XXX_Size() int {
	return m.Size()
}
func (m *ContainerStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainerStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ContainerStatus proto.InternalMessageInfo

func (m *ContainerStatus) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ContainerStatus) GetContainerState() ContainerState {
	if m != nil {
		return m.ContainerState
	}
	return CONTAINER_STATE_UNKNOWN
}

func (m *ContainerStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *ContainerStatus) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *ContainerStatus) GetStartTimestampNS() int64 {
	if m != nil {
		return m.StartTimestampNS
	}
	return 0
}

func (m *ContainerStatus) GetRestartCount() int64 {
	if m != nil {
		return m.RestartCount
	}
	return 0
}

type VizierPodStatus struct {
	Name              string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Phase             PodPhase           `protobuf:"varint,2,opt,name=phase,proto3,enum=px.api.vizierpb.PodPhase" json:"phase,omitempty"`
	Message           string             `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	Reason            string             `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"`
	CreatedAt         int64              `protobuf:"varint,5,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	ContainerStatuses []*ContainerStatus `protobuf:"bytes,6,rep,name=container_statuses,json=containerStatuses,proto3" json:"container_statuses,omitempty"`
	RestartCount      int64              `protobuf:"varint,7,opt,name=restart_count,json=restartCount,proto3" json:"restart_count,omitempty"`
}

func (m *VizierPodStatus) Reset()      { *m = VizierPodStatus{} }
func (*VizierPodStatus) ProtoMessage() {}
func (*VizierPodStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{29}
}
func (m *VizierPodStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VizierPodStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VizierPodStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *VizierPodStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VizierPodStatus.Merge(m, src)
}
func (m *VizierPodStatus) XXX_Size() int {
	return m.Size()
}
func (m *VizierPodStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_VizierPodStatus.DiscardUnknown(m)
}

var xxx_messageInfo_VizierPodStatus proto.InternalMessageInfo

func (m *VizierPodStatus) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *VizierPodStatus) GetPhase() PodPhase {
	if m != nil {
		return m.Phase
	}
	return PHASE_UNKNOWN
}

func (m *VizierPodStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *VizierPodStatus) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *VizierPodStatus) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *VizierPodStatus) GetContainerStatuses() []*ContainerStatus {
	if m != nil {
		return m.ContainerStatuses
	}
	return nil
}

func (m *VizierPodStatus) GetRestartCount() int64 {
	if m != nil {
		return m.RestartCount
	}
	return 0
}

type DebugPodsRequest struct {
	ClusterID string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
}

func (m *DebugPodsRequest) Reset()      { *m = DebugPodsRequest{} }
func (*DebugPodsRequest) ProtoMessage() {}
func (*DebugPodsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{30}
}
func (m *DebugPodsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DebugPodsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DebugPodsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DebugPodsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugPodsRequest.Merge(m, src)
}
func (m *DebugPodsRequest) XXX_Size() int {
	return m.Size()
}
func (m *DebugPodsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugPodsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DebugPodsRequest proto.InternalMessageInfo

func (m *DebugPodsRequest) GetClusterID() string {
	if m != nil {
		return m.ClusterID
	}
	return ""
}

type DebugPodsResponse struct {
	DataPlanePods    []*VizierPodStatus `protobuf:"bytes,1,rep,name=data_plane_pods,json=dataPlanePods,proto3" json:"data_plane_pods,omitempty"`
	ControlPlanePods []*VizierPodStatus `protobuf:"bytes,2,rep,name=control_plane_pods,json=controlPlanePods,proto3" json:"control_plane_pods,omitempty"`
}

func (m *DebugPodsResponse) Reset()      { *m = DebugPodsResponse{} }
func (*DebugPodsResponse) ProtoMessage() {}
func (*DebugPodsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1d71b88d88e6e715, []int{31}
}
func (m *DebugPodsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DebugPodsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DebugPodsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DebugPodsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugPodsResponse.Merge(m, src)
}
func (m *DebugPodsResponse) XXX_Size() int {
	return m.Size()
}
func (m *DebugPodsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugPodsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DebugPodsResponse proto.InternalMessageInfo

func (m *DebugPodsResponse) GetDataPlanePods() []*VizierPodStatus {
	if m != nil {
		return m.DataPlanePods
	}
	return nil
}

func (m *DebugPodsResponse) GetControlPlanePods() []*VizierPodStatus {
	if m != nil {
		return m.ControlPlanePods
	}
	return nil
}

func init() {
	proto.RegisterEnum("px.api.vizierpb.DataType", DataType_name, DataType_value)
	proto.RegisterEnum("px.api.vizierpb.SemanticType", SemanticType_name, SemanticType_value)
	proto.RegisterEnum("px.api.vizierpb.LifeCycleState", LifeCycleState_name, LifeCycleState_value)
	proto.RegisterEnum("px.api.vizierpb.ContainerState", ContainerState_name, ContainerState_value)
	proto.RegisterEnum("px.api.vizierpb.PodPhase", PodPhase_name, PodPhase_value)
	proto.RegisterType((*UInt128)(nil), "px.api.vizierpb.UInt128")
	proto.RegisterType((*BooleanColumn)(nil), "px.api.vizierpb.BooleanColumn")
	proto.RegisterType((*Int64Column)(nil), "px.api.vizierpb.Int64Column")
	proto.RegisterType((*UInt128Column)(nil), "px.api.vizierpb.UInt128Column")
	proto.RegisterType((*Float64Column)(nil), "px.api.vizierpb.Float64Column")
	proto.RegisterType((*Time64NSColumn)(nil), "px.api.vizierpb.Time64NSColumn")
	proto.RegisterType((*StringColumn)(nil), "px.api.vizierpb.StringColumn")
	proto.RegisterType((*Column)(nil), "px.api.vizierpb.Column")
	proto.RegisterType((*RowBatchData)(nil), "px.api.vizierpb.RowBatchData")
	proto.RegisterType((*Relation)(nil), "px.api.vizierpb.Relation")
	proto.RegisterType((*Relation_ColumnInfo)(nil), "px.api.vizierpb.Relation.ColumnInfo")
	proto.RegisterType((*CompilerError)(nil), "px.api.vizierpb.CompilerError")
	proto.RegisterType((*ErrorDetails)(nil), "px.api.vizierpb.ErrorDetails")
	proto.RegisterType((*Status)(nil), "px.api.vizierpb.Status")
	proto.RegisterType((*ScalarValue)(nil), "px.api.vizierpb.ScalarValue")
	proto.RegisterType((*ExecuteScriptRequest)(nil), "px.api.vizierpb.ExecuteScriptRequest")
	proto.RegisterType((*ExecuteScriptRequest_FuncToExecute)(nil), "px.api.vizierpb.ExecuteScriptRequest.FuncToExecute")
	proto.RegisterType((*ExecuteScriptRequest_FuncToExecute_ArgValue)(nil), "px.api.vizierpb.ExecuteScriptRequest.FuncToExecute.ArgValue")
	proto.RegisterType((*ExecuteScriptRequest_EncryptionOptions)(nil), "px.api.vizierpb.ExecuteScriptRequest.EncryptionOptions")
	proto.RegisterType((*Configs)(nil), "px.api.vizierpb.Configs")
	proto.RegisterType((*Configs_OTelEndpointConfig)(nil), "px.api.vizierpb.Configs.OTelEndpointConfig")
	proto.RegisterMapType((map[string]string)(nil), "px.api.vizierpb.Configs.OTelEndpointConfig.HeadersEntry")
	proto.RegisterType((*Configs_PluginConfig)(nil), "px.api.vizierpb.Configs.PluginConfig")
	proto.RegisterType((*QueryTimingInfo)(nil), "px.api.vizierpb.QueryTimingInfo")
	proto.RegisterType((*QueryExecutionStats)(nil), "px.api.vizierpb.QueryExecutionStats")
	proto.RegisterType((*QueryMetadata)(nil), "px.api.vizierpb.QueryMetadata")
	proto.RegisterType((*QueryData)(nil), "px.api.vizierpb.QueryData")
	proto.RegisterType((*ExecuteScriptResponse)(nil), "px.api.vizierpb.ExecuteScriptResponse")
	proto.RegisterType((*MutationInfo)(nil), "px.api.vizierpb.MutationInfo")
	proto.RegisterType((*MutationInfo_MutationState)(nil), "px.api.vizierpb.MutationInfo.MutationState")
	proto.RegisterType((*HealthCheckRequest)(nil), "px.api.vizierpb.HealthCheckRequest")
	proto.RegisterType((*HealthCheckResponse)(nil), "px.api.vizierpb.HealthCheckResponse")
	proto.RegisterType((*GenerateOTelScriptRequest)(nil), "px.api.vizierpb.GenerateOTelScriptRequest")
	proto.RegisterType((*GenerateOTelScriptResponse)(nil), "px.api.vizierpb.GenerateOTelScriptResponse")
	proto.RegisterType((*DebugLogRequest)(nil), "px.api.vizierpb.DebugLogRequest")
	proto.RegisterType((*DebugLogResponse)(nil), "px.api.vizierpb.DebugLogResponse")
	proto.RegisterType((*ContainerStatus)(nil), "px.api.vizierpb.ContainerStatus")
	proto.RegisterType((*VizierPodStatus)(nil), "px.api.vizierpb.VizierPodStatus")
	proto.RegisterType((*DebugPodsRequest)(nil), "px.api.vizierpb.DebugPodsRequest")
	proto.RegisterType((*DebugPodsResponse)(nil), "px.api.vizierpb.DebugPodsResponse")
}

func init() {
	proto.RegisterFile("src/api/proto/vizierpb/vizierapi.proto", fileDescriptor_1d71b88d88e6e715)
}

var fileDescriptor_1d71b88d88e6e715 = []byte{
	// 2960 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x59, 0x4d, 0x6c, 0x1b, 0xc7,
	0xf5, 0xe7, 0x92, 0x14, 0x3f, 0x1e, 0x49, 0x69, 0x35, 0x56, 0x6c, 0x99, 0x89, 0xa9, 0x84, 0x76,
	0xfc, 0x37, 0xec, 0xfc, 0xa5, 0x44, 0x71, 0x5c, 0x23, 0x68, 0xd2, 0xf0, 0x63, 0x65, 0x32, 0xb1,
	0x96, 0xf4, 0xec, 0x32, 0x41, 0xd2, 0xc3, 0x66, 0xb5, 0x1c, 0x49, 0x1b, 0x93, 0xbb, 0xcc, 0xee,
	0xd2, 0xb2, 0x7a, 0x28, 0x72, 0x68, 0x1b, 0xa0, 0x97, 0xa6, 0x45, 0x0e, 0xbd, 0x14, 0x28, 0x0a,
	0x14, 0xc8, 0x21, 0x45, 0x7b, 0xcc, 0x21, 0xed, 0x39, 0x05, 0x7a, 0xc8, 0x31, 0xfd, 0x80, 0xd0,
	0x28, 0x97, 0xf4, 0xd4, 0x1c, 0x5a, 0x20, 0xc7, 0x62, 0x3e, 0x96, 0xda, 0x15, 0x29, 0xc5, 0xf1,
	0x49, 0x3b, 0x6f, 0x7e, 0xef, 0xf7, 0xde, 0xbc, 0x37, 0xf3, 0xe6, 0x0d, 0x05, 0x97, 0x7d, 0xcf,
	0x5a, 0x33, 0x47, 0xf6, 0xda, 0xc8, 0x73, 0x03, 0x77, 0xed, 0x9e, 0xfd, 0x03, 0x9b, 0x78, 0xa3,
	0x2d, 0xf1, 0x61, 0x8e, 0xec, 0x55, 0x36, 0x81, 0x16, 0x46, 0xf7, 0x57, 0xe9, 0x28, 0x04, 0x94,
	0xff, 0x7f, 0xc7, 0x0e, 0x76, 0xc7, 0x5b, 0xab, 0x96, 0x3b, 0x5c, 0xdb, 0x71, 0x77, 0x5c, 0x4e,
	0xb0, 0x35, 0xde, 0x66, 0x23, 0xce, 0x46, 0xbf, 0xb8, 0x7e, 0x75, 0x0d, 0xb2, 0xbd, 0xb6, 0x13,
	0x3c, 0xb3, 0x7e, 0x13, 0xc9, 0x90, 0x1a, 0xb8, 0x7b, 0xcb, 0xd2, 0xe3, 0xd2, 0x95, 0x34, 0xa6,
	0x9f, 0x08, 0x41, 0x7a, 0xd7, 0xde, 0xd9, 0x5d, 0x4e, 0x32, 0x11, 0xfb, 0xae, 0x5e, 0x84, 0x52,
	0xdd, 0x75, 0x07, 0xc4, 0x74, 0x1a, 0xee, 0x60, 0x3c, 0x74, 0x28, 0xa8, 0x6f, 0x06, 0xe6, 0xb2,
	0xf4, 0x78, 0xea, 0x4a, 0x0e, 0xb3, 0xef, 0xea, 0x13, 0x50, 0x68, 0x3b, 0xc1, 0x8d, 0xeb, 0x33,
	0x20, 0x29, 0x01, 0x79, 0x01, 0x4a, 0xc2, 0xb0, 0x00, 0x3d, 0x15, 0x01, 0x15, 0xd6, 0x97, 0x57,
	0x8f, 0x2d, 0x6c, 0x55, 0xa0, 0x85, 0xfa, 0x45, 0x28, 0x6d, 0x0c, 0x5c, 0x73, 0xb6, 0x0d, 0x49,
	0x80, 0x2e, 0xc1, 0xbc, 0x6e, 0x0f, 0xc9, 0x8d, 0xeb, 0xaa, 0x76, 0x8a, 0x27, 0x55, 0x28, 0x6a,
	0x81, 0x67, 0x3b, 0x3b, 0x33, 0x30, 0x45, 0x81, 0xf9, 0x30, 0x05, 0x19, 0x31, 0xdd, 0x80, 0xe2,
	0x16, 0x0f, 0x80, 0x21, 0x60, 0xd2, 0x95, 0xc2, 0x7a, 0x65, 0xca, 0xdf, 0x58, 0x94, 0x5a, 0x09,
	0x5c, 0x10, 0x5a, 0x4d, 0x33, 0x30, 0xd1, 0x0b, 0x00, 0x36, 0x0d, 0x10, 0xa7, 0x48, 0x32, 0x8a,
	0xc7, 0xa6, 0x28, 0x22, 0x31, 0x6c, 0x25, 0x70, 0x9e, 0x69, 0x30, 0xf5, 0x06, 0x14, 0xc7, 0x36,
	0x0b, 0x07, 0x27, 0x48, 0x9d, 0xe0, 0x43, 0x2c, 0xc2, 0xd4, 0x07, 0xa1, 0xc5, 0x48, 0x36, 0xa0,
	0x14, 0xb0, 0xe8, 0x38, 0x3e, 0x67, 0x49, 0x33, 0x96, 0x95, 0x29, 0x96, 0x78, 0x0c, 0x5b, 0x09,
	0x5c, 0x0c, 0xf5, 0x42, 0x67, 0xb6, 0x79, 0x2a, 0x38, 0xcd, 0xdc, 0x09, 0xce, 0xc4, 0xf2, 0x45,
	0x9d, 0x11, 0x5a, 0x8c, 0xe4, 0x25, 0x28, 0xf8, 0x2c, 0x09, 0x9c, 0x23, 0xc3, 0x38, 0x2e, 0x4c,
	0x71, 0x44, 0x13, 0xd5, 0x4a, 0x60, 0xe0, 0x3a, 0x94, 0xa1, 0x0e, 0x90, 0xb3, 0xdc, 0x01, 0x53,
	0xaf, 0xfe, 0x46, 0x82, 0x22, 0x76, 0xf7, 0xea, 0x66, 0x60, 0xed, 0x32, 0xfa, 0xcb, 0x90, 0x0b,
	0xcc, 0xad, 0x01, 0x31, 0xec, 0x3e, 0xf3, 0x2f, 0x5f, 0x2f, 0x1c, 0x1e, 0xac, 0x64, 0x75, 0x2a,
	0x6b, 0x37, 0x71, 0x96, 0x4d, 0xb6, 0xfb, 0xe8, 0x1a, 0xa4, 0x2d, 0x77, 0xe0, 0x8b, 0x4d, 0x78,
	0x6e, 0xca, 0x3e, 0xb7, 0x8c, 0x19, 0x08, 0x9d, 0x87, 0x9c, 0x33, 0x1e, 0x1a, 0x9e, 0xbb, 0xe7,
	0xb3, 0x14, 0xa6, 0x70, 0xd6, 0x19, 0x0f, 0xb1, 0xbb, 0xe7, 0xd3, 0xb3, 0x44, 0xdc, 0x3d, 0x96,
	0x97, 0x1c, 0xa6, 0x9f, 0x5c, 0xe2, 0xb3, 0x18, 0x33, 0x89, 0x5f, 0xfd, 0x20, 0x09, 0x39, 0x4c,
	0x06, 0x66, 0x60, 0xbb, 0x0e, 0x7a, 0x11, 0xb2, 0x16, 0xe3, 0x0e, 0x6d, 0x5f, 0x9a, 0xb2, 0x1d,
	0x62, 0x85, 0x13, 0x6d, 0x67, 0xdb, 0xc5, 0xa1, 0x52, 0xf9, 0xef, 0x12, 0xc0, 0x91, 0x1c, 0xad,
	0x40, 0x81, 0xcf, 0x18, 0x8e, 0x39, 0x24, 0x6c, 0x8f, 0xe6, 0x31, 0x70, 0x91, 0x6a, 0x0e, 0x09,
	0x7a, 0x7e, 0x02, 0x08, 0xf6, 0x47, 0x84, 0xb9, 0x3f, 0xbf, 0x7e, 0x7e, 0xca, 0x26, 0x0d, 0x9e,
	0xbe, 0x3f, 0x22, 0xa1, 0x2e, 0xfd, 0x8e, 0x90, 0xf7, 0x89, 0x6f, 0xb1, 0x45, 0x4e, 0xc8, 0x9b,
	0xc4, 0xb7, 0x50, 0x07, 0x96, 0x04, 0xc0, 0x27, 0x43, 0xd3, 0x09, 0x6c, 0x8b, 0x5b, 0x49, 0x33,
	0x2b, 0x33, 0xb2, 0x2a, 0x50, 0xcc, 0x12, 0xe2, 0xaa, 0x51, 0x59, 0xb5, 0x07, 0xa5, 0x86, 0x3b,
	0x1c, 0xd9, 0x03, 0xe2, 0x29, 0x9e, 0xe7, 0x7a, 0xf4, 0x8c, 0x0e, 0x6c, 0x87, 0x88, 0x62, 0xc5,
	0xbe, 0xd1, 0x59, 0xc8, 0x70, 0x55, 0x51, 0xaf, 0xc4, 0x08, 0x2d, 0x43, 0x76, 0x48, 0x7c, 0xdf,
	0xdc, 0x21, 0xc2, 0xd5, 0x70, 0x58, 0x7d, 0x13, 0x8a, 0x8c, 0xae, 0x49, 0x02, 0xd3, 0x1e, 0xf8,
	0xe8, 0x16, 0xcc, 0x5b, 0xc2, 0x8c, 0x41, 0xe8, 0xc4, 0x89, 0x87, 0x3b, 0xe6, 0x4d, 0x2b, 0x81,
	0x4b, 0x56, 0x54, 0x50, 0xcf, 0xc2, 0x1c, 0xd3, 0xaf, 0xbe, 0x23, 0x41, 0x46, 0x0b, 0xcc, 0x60,
	0xec, 0x53, 0x97, 0x2d, 0xb7, 0xcf, 0x5d, 0x9e, 0xc3, 0xec, 0x3b, 0xea, 0x5a, 0x32, 0xe6, 0x1a,
	0xaa, 0x43, 0x89, 0x31, 0x18, 0x7d, 0xee, 0xdb, 0x72, 0x9a, 0xed, 0x8a, 0xe9, 0xd8, 0x45, 0x17,
	0x80, 0x8b, 0x24, 0x32, 0x7a, 0x39, 0x9d, 0x4b, 0xc9, 0xe9, 0xea, 0x9f, 0x93, 0x50, 0xd0, 0x2c,
	0x73, 0x60, 0x7a, 0xaf, 0x9a, 0x83, 0x31, 0x41, 0x37, 0x20, 0x4f, 0xcf, 0x08, 0xcf, 0x88, 0xf4,
	0x4d, 0x79, 0xcf, 0xf5, 0xc5, 0x17, 0x5a, 0x01, 0xa0, 0x15, 0xcc, 0xb8, 0x47, 0x59, 0x98, 0xbb,
	0x39, 0x5a, 0x94, 0xa8, 0x8c, 0x13, 0x3f, 0x01, 0x05, 0x5e, 0xd3, 0x38, 0x82, 0xc6, 0x3a, 0x45,
	0xcf, 0x28, 0x13, 0x72, 0xc8, 0x93, 0x50, 0x0a, 0x4b, 0x05, 0x07, 0xd1, 0x1d, 0x21, 0xd1, 0x8a,
	0x22, 0xc4, 0x1c, 0x76, 0x11, 0x8a, 0xa2, 0x18, 0x70, 0x14, 0x3b, 0xb1, 0xb4, 0x62, 0x70, 0x29,
	0x07, 0x5d, 0x81, 0x05, 0x5e, 0x86, 0x0c, 0xc7, 0x17, 0xb8, 0x8c, 0x30, 0x29, 0xea, 0x9a, 0xea,
	0x73, 0xe4, 0xf7, 0xa0, 0x14, 0x56, 0x4b, 0x8e, 0xcb, 0xb2, 0xac, 0x9e, 0x78, 0xc5, 0x50, 0x7f,
	0x84, 0x02, 0x23, 0xa0, 0xe9, 0x64, 0x8a, 0xd5, 0x3f, 0x65, 0x60, 0x49, 0xb9, 0x4f, 0xac, 0x71,
	0x40, 0x34, 0xcb, 0xb3, 0x47, 0x01, 0x26, 0x6f, 0x8f, 0x89, 0x1f, 0xa0, 0x47, 0x21, 0xff, 0xf6,
	0x98, 0x78, 0xfb, 0x86, 0x1f, 0x78, 0xe2, 0xb4, 0xe5, 0x98, 0x40, 0x0b, 0x3c, 0xf4, 0x14, 0x80,
	0x35, 0x18, 0xfb, 0x01, 0xf1, 0x68, 0xf9, 0x61, 0x7b, 0xb0, 0x5e, 0x3a, 0x3c, 0x58, 0xc9, 0x37,
	0xb8, 0xb4, 0xdd, 0xc4, 0x79, 0x01, 0x68, 0xf7, 0x11, 0x06, 0x20, 0xf7, 0x89, 0x65, 0x6c, 0x8f,
	0x1d, 0x2b, 0x4c, 0xfb, 0xb3, 0xd3, 0x69, 0x9f, 0xe1, 0xc5, 0xea, 0xc6, 0xd8, 0xb1, 0x74, 0x57,
	0x4c, 0xe1, 0x3c, 0xa5, 0xa1, 0x22, 0x1f, 0x95, 0x21, 0x37, 0x1c, 0x07, 0xac, 0x7a, 0xb0, 0x60,
	0xe6, 0xf0, 0x64, 0x8c, 0xb6, 0x01, 0x11, 0xc7, 0xf2, 0xf6, 0x47, 0x74, 0x64, 0xb8, 0xec, 0x8f,
	0x2f, 0x0a, 0xf0, 0x77, 0x1e, 0xcc, 0xae, 0x32, 0xd1, 0xef, 0x70, 0x75, 0xbc, 0x48, 0x8e, 0x8b,
	0x68, 0x09, 0xe6, 0x21, 0xb2, 0xfb, 0x2c, 0x01, 0xa2, 0x04, 0xdf, 0xa1, 0x32, 0x5a, 0x82, 0xd9,
	0x64, 0xbb, 0x8f, 0xd6, 0x69, 0x25, 0x74, 0xb6, 0xed, 0x1d, 0x7f, 0x39, 0x7f, 0x42, 0x9e, 0x1a,
	0x7c, 0x1e, 0x87, 0x40, 0x74, 0x01, 0x80, 0x73, 0xb3, 0x6a, 0x07, 0x2c, 0xfe, 0x3c, 0x21, 0xb4,
	0xd8, 0x95, 0xff, 0x2d, 0x41, 0x29, 0x16, 0x1b, 0x9a, 0x2f, 0x1a, 0xdf, 0x68, 0x75, 0xcc, 0x51,
	0x01, 0xab, 0x8d, 0xdf, 0x07, 0x30, 0x3d, 0xb1, 0xf7, 0x68, 0x65, 0xa7, 0x19, 0xf8, 0xee, 0x43,
	0x64, 0x60, 0xb5, 0xe6, 0xf1, 0xbd, 0x8a, 0xf3, 0xa6, 0xf8, 0xf2, 0xd1, 0x2a, 0x9c, 0x71, 0xc7,
	0xc1, 0x68, 0x1c, 0x18, 0xfc, 0x42, 0x1a, 0x79, 0x64, 0xdb, 0xbe, 0x2f, 0x2a, 0xd3, 0x22, 0x9f,
	0x62, 0xd7, 0x52, 0x97, 0x4d, 0x94, 0xaf, 0x43, 0x2e, 0xa4, 0xa1, 0x25, 0x24, 0xe2, 0x30, 0xfb,
	0x46, 0x4b, 0x62, 0x6f, 0x8a, 0x02, 0xc2, 0x07, 0xe5, 0x9f, 0x49, 0xb0, 0x38, 0x95, 0x15, 0x74,
	0x0e, 0xb2, 0x6f, 0xed, 0xdd, 0x35, 0xee, 0x92, 0x7d, 0x41, 0x91, 0x79, 0x6b, 0xef, 0xee, 0x2b,
	0x64, 0x9f, 0x4e, 0xdc, 0x25, 0xfb, 0x86, 0x39, 0xd8, 0x11, 0x34, 0x99, 0xbb, 0x64, 0xbf, 0x36,
	0xd8, 0xe1, 0xa5, 0xde, 0x09, 0x88, 0x13, 0xb0, 0xc9, 0x49, 0xa9, 0x67, 0x22, 0x0a, 0xf8, 0x3f,
	0x58, 0xa0, 0xa5, 0xcf, 0x23, 0xbe, 0x4f, 0xb7, 0x0f, 0x05, 0xa5, 0x19, 0x68, 0x3e, 0x22, 0xae,
	0x0d, 0x76, 0x5e, 0x4e, 0xe7, 0x92, 0x72, 0xaa, 0xfa, 0xcb, 0x34, 0x64, 0x45, 0xf6, 0xd0, 0x18,
	0x96, 0xdc, 0x80, 0x0c, 0x0c, 0xe2, 0xf4, 0x47, 0xae, 0xed, 0x04, 0x06, 0xcf, 0xa6, 0xa8, 0xb9,
	0xd7, 0x4e, 0xca, 0xfa, 0x6a, 0x47, 0x27, 0x03, 0x45, 0xe8, 0x70, 0x59, 0xfd, 0xec, 0xe1, 0xc1,
	0x0a, 0x9a, 0x96, 0x63, 0x44, 0x0d, 0xc4, 0x65, 0xe8, 0x65, 0x28, 0x8d, 0x06, 0xe3, 0x1d, 0xdb,
	0x09, 0xed, 0xf1, 0xee, 0xeb, 0xc9, 0x13, 0xed, 0x75, 0x19, 0x5a, 0x30, 0x16, 0x47, 0x91, 0x51,
	0xf9, 0xbf, 0x12, 0xcc, 0x30, 0x8b, 0xce, 0x43, 0x6a, 0xec, 0x0d, 0x78, 0x8c, 0xeb, 0xd9, 0xc3,
	0x83, 0x95, 0x54, 0x0f, 0xdf, 0xc6, 0x54, 0x86, 0x30, 0x64, 0x77, 0x89, 0xd9, 0x27, 0x5e, 0xb8,
	0xb1, 0x6e, 0x7e, 0x8b, 0x75, 0xae, 0xb6, 0xb8, 0xaa, 0xe2, 0x04, 0xde, 0x3e, 0x0e, 0x89, 0xe8,
	0xe9, 0xb6, 0x1d, 0x9f, 0x58, 0x63, 0x8f, 0x88, 0x8e, 0x63, 0x32, 0xa6, 0x37, 0x0c, 0x2d, 0x86,
	0xee, 0x38, 0x60, 0x79, 0x49, 0xe1, 0x70, 0x58, 0x7e, 0x1e, 0x8a, 0x51, 0x3a, 0xda, 0xa0, 0x1c,
	0x6d, 0x0c, 0xfa, 0x39, 0x7b, 0x6b, 0x3d, 0x9f, 0xbc, 0x29, 0x95, 0x31, 0x14, 0xa3, 0x51, 0x41,
	0x55, 0x28, 0xf9, 0x81, 0xe9, 0x05, 0x06, 0x25, 0x37, 0x58, 0x0f, 0x43, 0x6d, 0x15, 0x98, 0x90,
	0xb6, 0x8f, 0xaa, 0x8f, 0x2a, 0x50, 0x20, 0x4e, 0x7f, 0x82, 0xe0, 0x0d, 0x53, 0x9e, 0x38, 0x7d,
	0x3e, 0x5f, 0x1d, 0xc2, 0x02, 0xab, 0x05, 0xba, 0x3d, 0xb4, 0x9d, 0x1d, 0xd6, 0xc5, 0x5c, 0x85,
	0x45, 0xc2, 0x8e, 0x12, 0xdd, 0x5a, 0x71, 0xea, 0x85, 0xc9, 0x84, 0xa0, 0x5f, 0x85, 0x33, 0xfc,
	0x0e, 0x36, 0x63, 0x68, 0x6e, 0x66, 0x31, 0x32, 0x25, 0xcc, 0xfd, 0x56, 0x82, 0x33, 0xcc, 0x9e,
	0x12, 0x12, 0xd1, 0x7b, 0xda, 0x47, 0x37, 0x21, 0x13, 0x30, 0x0f, 0xc4, 0x3e, 0x7c, 0x7c, 0x2a,
	0x3f, 0xc7, 0xbc, 0xc4, 0x02, 0x4f, 0x8f, 0xc2, 0xd6, 0x7e, 0x40, 0x7c, 0x63, 0xe4, 0xb9, 0x16,
	0xf1, 0x7d, 0xd2, 0x17, 0xd6, 0xe7, 0x99, 0xb8, 0x1b, 0x4a, 0xd1, 0x35, 0x58, 0xf4, 0x88, 0xe5,
	0x7a, 0xfd, 0x28, 0x94, 0x5d, 0x97, 0x58, 0x16, 0x13, 0x13, 0x70, 0xd5, 0x83, 0x12, 0x33, 0xb8,
	0x49, 0x02, 0x93, 0xde, 0xc5, 0xe8, 0x39, 0xc8, 0x79, 0xa2, 0x13, 0x14, 0x2e, 0x9e, 0x3f, 0xb1,
	0x55, 0xc4, 0x13, 0xe8, 0xa4, 0x76, 0x24, 0x23, 0xb5, 0xe3, 0x2c, 0x24, 0x27, 0x17, 0x52, 0xe6,
	0xf0, 0x60, 0x25, 0xd9, 0x6e, 0xe2, 0xa4, 0xdd, 0xaf, 0x7e, 0x24, 0x41, 0x9e, 0x19, 0x65, 0xbd,
	0xf3, 0xb3, 0x30, 0xb7, 0x45, 0x1b, 0x69, 0x61, 0x6d, 0xba, 0x05, 0x89, 0x76, 0xda, 0x98, 0x63,
	0x69, 0x30, 0xc4, 0x15, 0x40, 0xfa, 0x06, 0x57, 0xa7, 0x76, 0x8a, 0x78, 0x7e, 0x22, 0x66, 0x3a,
	0x68, 0x13, 0x8e, 0x52, 0x69, 0xf8, 0x34, 0x05, 0xe2, 0x40, 0x5e, 0x9a, 0x1d, 0xf8, 0x78, 0xba,
	0xf0, 0x3c, 0x89, 0x8d, 0xab, 0xbf, 0x4f, 0xc2, 0x23, 0xc7, 0x2a, 0xb3, 0x3f, 0x72, 0x1d, 0x9f,
	0xa0, 0x35, 0xc8, 0xf8, 0xac, 0x13, 0x13, 0xeb, 0x38, 0x37, 0xe3, 0x71, 0x41, 0xa7, 0xb1, 0x80,
	0xc5, 0x2e, 0xac, 0xe4, 0x29, 0x17, 0xd6, 0xd3, 0xe2, 0xbd, 0xc8, 0x1f, 0x61, 0xe5, 0xd9, 0x6e,
	0xd3, 0xd8, 0xb4, 0x12, 0xfc, 0x35, 0x89, 0x5e, 0x80, 0xfc, 0x90, 0x04, 0x66, 0xf4, 0xd5, 0x55,
	0x99, 0xad, 0x16, 0x66, 0xbd, 0x95, 0xc0, 0x39, 0xaa, 0xc2, 0x12, 0x52, 0x87, 0x52, 0x78, 0x7b,
	0x1b, 0xb6, 0xb3, 0xed, 0x8a, 0x17, 0xd7, 0x74, 0x62, 0x36, 0x05, 0x8a, 0x6d, 0xd3, 0xe2, 0x30,
	0x32, 0xaa, 0xe7, 0x20, 0xe3, 0x11, 0x7f, 0x3c, 0x08, 0xaa, 0x5f, 0x4b, 0x50, 0x8c, 0x02, 0xbf,
	0x7d, 0xa0, 0x1a, 0x5c, 0x61, 0x72, 0x57, 0x5e, 0x3b, 0xd5, 0x91, 0xc9, 0x80, 0xb2, 0x10, 0x2c,
	0x54, 0xcb, 0x1e, 0x94, 0x62, 0x13, 0x62, 0x73, 0x4a, 0xc7, 0x37, 0x27, 0x7a, 0x0e, 0xe6, 0x98,
	0x8a, 0x78, 0xb3, 0x4c, 0x3f, 0x57, 0x6f, 0xdb, 0xdb, 0xa4, 0xb1, 0x6f, 0x0d, 0x08, 0x37, 0xc0,
	0xd1, 0x93, 0xfd, 0x9f, 0x3a, 0xda, 0xff, 0xd5, 0x3a, 0xa0, 0x16, 0x31, 0x07, 0xc1, 0x6e, 0x63,
	0x97, 0x58, 0x77, 0xc3, 0x5e, 0x2e, 0xde, 0xae, 0x49, 0xa7, 0xb7, 0x6b, 0xd5, 0x0d, 0x38, 0x13,
	0xe3, 0x78, 0xc8, 0xdd, 0x56, 0xdd, 0x85, 0xf3, 0xb7, 0x88, 0x43, 0x3c, 0x33, 0x20, 0xb4, 0xf0,
	0xc7, 0xdb, 0xcb, 0x6f, 0xe5, 0x12, 0xed, 0x86, 0x46, 0xf7, 0x07, 0x86, 0xcf, 0x28, 0xc4, 0x81,
	0xcf, 0x8f, 0xee, 0x0b, 0xce, 0xea, 0x0f, 0xa1, 0x3c, 0xcb, 0xd2, 0xc3, 0x1e, 0x93, 0x35, 0x28,
	0xb0, 0x6b, 0x3c, 0x6a, 0xae, 0x3e, 0x7f, 0x78, 0xb0, 0x02, 0x11, 0x76, 0xa0, 0x10, 0x61, 0xff,
	0x7d, 0x09, 0x16, 0x9a, 0x64, 0x6b, 0xbc, 0x73, 0xdb, 0xdd, 0x79, 0xb8, 0x05, 0x9e, 0x87, 0xdc,
	0xc8, 0xed, 0x1b, 0x91, 0x7a, 0x96, 0x1d, 0xb9, 0x7d, 0xd6, 0xbb, 0x95, 0x21, 0x37, 0xf2, 0xc8,
	0x3d, 0xdb, 0x1d, 0xfb, 0xe1, 0x5d, 0x18, 0x8e, 0xd1, 0x63, 0x90, 0xa7, 0x9d, 0x8b, 0x69, 0x3b,
	0xc4, 0x13, 0x5d, 0xca, 0x91, 0xa0, 0x7a, 0x19, 0xe4, 0x23, 0xaf, 0x44, 0x30, 0xc2, 0x9f, 0x82,
	0x44, 0xd1, 0x64, 0xbf, 0x2d, 0xfc, 0x34, 0x09, 0x0b, 0x8d, 0x50, 0xeb, 0xe8, 0x6d, 0x37, 0xd5,
	0x98, 0xb5, 0x68, 0x67, 0x24, 0x60, 0xc6, 0xe9, 0x3b, 0x36, 0x46, 0x47, 0x68, 0xeb, 0x14, 0x1d,
	0x9f, 0xfc, 0x80, 0xa5, 0x4f, 0x5e, 0x8f, 0x98, 0xbe, 0xeb, 0x88, 0xe5, 0x88, 0x11, 0xaa, 0x03,
	0x3a, 0xba, 0x8f, 0xfd, 0xc0, 0x1c, 0x8e, 0xe8, 0x5d, 0x48, 0xcb, 0x44, 0xaa, 0xbe, 0x74, 0x78,
	0xb0, 0x22, 0x6b, 0xe1, 0xc5, 0xcc, 0x26, 0x55, 0x0d, 0xcb, 0x7e, 0x5c, 0xe2, 0xa3, 0x8b, 0x50,
	0xf2, 0x08, 0x67, 0xb1, 0xdc, 0xb1, 0x13, 0xf0, 0xd7, 0x15, 0x2e, 0x0a, 0x61, 0x83, 0xca, 0xaa,
	0xbf, 0x4a, 0xc2, 0xc2, 0xab, 0x6c, 0x19, 0x5d, 0xb7, 0x7f, 0x4a, 0x30, 0xd6, 0x60, 0x6e, 0xb4,
	0x6b, 0xfa, 0x27, 0xff, 0xd0, 0xd0, 0x75, 0xfb, 0x5d, 0x0a, 0xc0, 0x1c, 0xf7, 0x10, 0x6b, 0xbe,
	0x00, 0x60, 0x79, 0xc4, 0xa4, 0xf7, 0x8d, 0x19, 0xf0, 0xb5, 0xe2, 0xbc, 0x90, 0xd4, 0x02, 0xd4,
	0x01, 0x14, 0x4f, 0xc7, 0xd8, 0x27, 0xf4, 0x99, 0x93, 0x9a, 0x79, 0xc7, 0x1f, 0x4b, 0x30, 0x6d,
	0x20, 0x62, 0x02, 0x32, 0x23, 0x3e, 0xd9, 0x19, 0xf1, 0x79, 0x49, 0x6c, 0xaa, 0xae, 0xdb, 0xf7,
	0x1f, 0xae, 0xbe, 0xfc, 0x4e, 0x82, 0xc5, 0x08, 0x85, 0xd8, 0x98, 0x2d, 0x58, 0x60, 0x8f, 0xf8,
	0xd1, 0xc0, 0x74, 0x88, 0x31, 0x72, 0xfb, 0xe1, 0xcf, 0x46, 0xd3, 0x4b, 0x39, 0x96, 0x1e, 0x5c,
	0xa2, 0x8a, 0x5d, 0xaa, 0x47, 0x19, 0x91, 0xca, 0xe3, 0xe2, 0xb9, 0x83, 0x28, 0x59, 0xf2, 0x01,
	0xc9, 0x64, 0xa1, 0x3b, 0xe1, 0xbb, 0x3a, 0x84, 0x5c, 0xf8, 0xe3, 0x01, 0x7a, 0x04, 0x16, 0x9b,
	0x35, 0xbd, 0x66, 0xe8, 0xaf, 0x77, 0x15, 0xa3, 0xa7, 0xbe, 0xa2, 0x76, 0x5e, 0x53, 0xe5, 0x04,
	0x2a, 0x40, 0xb6, 0xde, 0xe9, 0xdc, 0x56, 0x6a, 0xaa, 0x2c, 0xa1, 0x3c, 0xcc, 0xb5, 0x55, 0xfd,
	0xc6, 0x75, 0x39, 0x49, 0xe5, 0xbd, 0xb6, 0xaa, 0x3f, 0xb3, 0x7e, 0x53, 0x4e, 0xd1, 0xc1, 0xc6,
	0xed, 0x4e, 0x8d, 0xce, 0xa4, 0x11, 0x40, 0x46, 0xd3, 0x71, 0x5b, 0xbd, 0x25, 0xcf, 0xa1, 0x22,
	0xe4, 0xf4, 0xf6, 0xa6, 0x72, 0xe3, 0xba, 0xaa, 0xc9, 0x99, 0xab, 0x07, 0x69, 0x28, 0x46, 0x7f,
	0x2a, 0x42, 0x08, 0xe6, 0x35, 0xdd, 0xe8, 0xa9, 0x5a, 0x57, 0x69, 0xb4, 0x37, 0xda, 0x4a, 0x93,
	0x1b, 0xd4, 0x74, 0x43, 0xed, 0xa8, 0x8a, 0x2c, 0xa1, 0x79, 0x00, 0x4d, 0x37, 0x28, 0x85, 0xa1,
	0x6a, 0x72, 0x12, 0xc9, 0x50, 0xd4, 0x74, 0xa3, 0x76, 0x4b, 0x51, 0x75, 0xa3, 0xd7, 0x6e, 0xca,
	0x7d, 0x01, 0xaf, 0x69, 0xed, 0xa6, 0x4c, 0x50, 0x91, 0x0d, 0x7a, 0xdd, 0x76, 0x53, 0xfe, 0x44,
	0x42, 0x4b, 0xb0, 0xa0, 0xe9, 0x86, 0xa6, 0xe0, 0x57, 0xdb, 0x0d, 0xc5, 0x50, 0x6b, 0x9b, 0x8a,
	0xfc, 0x21, 0xa5, 0x28, 0x68, 0xba, 0xd1, 0xed, 0x34, 0xb9, 0xe4, 0xbd, 0x14, 0x5a, 0x64, 0xa4,
	0x54, 0xd2, 0x6d, 0xd5, 0x34, 0x45, 0xfe, 0x79, 0x0a, 0x21, 0x28, 0x09, 0x91, 0xa6, 0xd7, 0xf4,
	0x9e, 0x26, 0xff, 0x22, 0x84, 0xa9, 0x9d, 0xa6, 0xe0, 0xfa, 0x4f, 0x0a, 0x9d, 0x85, 0x45, 0x4d,
	0x37, 0x1a, 0x1d, 0x55, 0xaf, 0xb5, 0x55, 0x05, 0x73, 0xf9, 0x67, 0x69, 0x74, 0x0e, 0x50, 0x4c,
	0x4e, 0x49, 0x14, 0xf9, 0xaf, 0x69, 0xb4, 0x0c, 0x67, 0xa6, 0x26, 0x7a, 0x9a, 0xfc, 0xb7, 0xb4,
	0xa0, 0xa2, 0x04, 0x5a, 0xb7, 0x16, 0xba, 0xfb, 0xf1, 0x1c, 0x2a, 0x41, 0x4e, 0xd3, 0x8d, 0xfa,
	0xeb, 0xba, 0xa2, 0xc9, 0xbf, 0xce, 0xa0, 0x05, 0x16, 0x90, 0xae, 0x82, 0x1b, 0x8a, 0xaa, 0xcb,
	0x3f, 0xca, 0xa2, 0x33, 0x2c, 0x84, 0xcd, 0x1e, 0xae, 0xe9, 0xed, 0x8e, 0x4a, 0xa3, 0xf4, 0xe3,
	0x2c, 0x3a, 0x0f, 0x4b, 0x34, 0x6c, 0x2d, 0xdc, 0xe9, 0xdd, 0x6a, 0x75, 0x7b, 0x4c, 0x81, 0x4e,
	0xfd, 0x24, 0x8b, 0x56, 0xa0, 0x1c, 0x9f, 0x62, 0xd4, 0x21, 0xe0, 0xdd, 0xac, 0x58, 0xe6, 0x9d,
	0x5e, 0x4d, 0xd5, 0xdb, 0xb7, 0x15, 0x4d, 0xfe, 0x32, 0x8b, 0x2e, 0xc0, 0x72, 0xdc, 0x46, 0x64,
	0xfa, 0x5f, 0x59, 0x11, 0xac, 0x76, 0xd7, 0xa8, 0x35, 0x9b, 0x58, 0xd1, 0x34, 0xf9, 0x2f, 0x39,
	0x91, 0x89, 0x6e, 0x07, 0xeb, 0xf2, 0x1f, 0xf2, 0x22, 0x1e, 0x2d, 0x5d, 0xef, 0x1a, 0x58, 0xb9,
	0x63, 0x6c, 0x2a, 0x7a, 0xab, 0xd3, 0x94, 0xdf, 0x07, 0x11, 0x0f, 0x31, 0xa1, 0x75, 0xc3, 0x78,
	0x7c, 0x0d, 0x62, 0x09, 0x47, 0x33, 0x9b, 0x8a, 0xa6, 0xd5, 0x6e, 0x29, 0xf2, 0x3f, 0x0a, 0x42,
	0x49, 0x6b, 0xe0, 0x76, 0x57, 0x37, 0xb0, 0xb2, 0xa1, 0x60, 0x45, 0x6d, 0x28, 0xf2, 0x47, 0xe7,
	0xae, 0xbe, 0x0d, 0xf3, 0xf1, 0x86, 0x02, 0x2d, 0x42, 0x49, 0xec, 0x65, 0x91, 0x84, 0x04, 0x15,
	0x75, 0x15, 0xb5, 0xd9, 0x56, 0x6f, 0x09, 0x91, 0x44, 0x45, 0xb8, 0xa7, 0xaa, 0x47, 0x22, 0xb6,
	0xd3, 0x36, 0x6a, 0xed, 0xdb, 0x4a, 0x53, 0x48, 0x52, 0x68, 0x09, 0x64, 0x5d, 0xc1, 0x9b, 0x6d,
	0xb5, 0xa6, 0x4f, 0xa4, 0xe9, 0xab, 0xef, 0x4a, 0x30, 0x1f, 0xbf, 0x12, 0xd0, 0xa3, 0x70, 0xee,
	0x58, 0xea, 0x23, 0xe7, 0x69, 0xc6, 0xa4, 0x30, 0x2d, 0x4b, 0xa8, 0x02, 0xe5, 0xe3, 0x93, 0x47,
	0x26, 0xe5, 0xe4, 0x2c, 0xe5, 0xd7, 0x6a, 0x6d, 0x9d, 0x2a, 0xa7, 0xae, 0x62, 0xc8, 0x85, 0x85,
	0x99, 0xad, 0x91, 0xee, 0xe5, 0xf8, 0x41, 0x16, 0xcb, 0x96, 0x25, 0x3a, 0x08, 0xad, 0x26, 0x51,
	0x09, 0xf2, 0x5a, 0xaf, 0xd1, 0x50, 0x94, 0xa6, 0xd2, 0x94, 0x53, 0xf4, 0xfc, 0xf2, 0x95, 0xcb,
	0xe9, 0xf5, 0x8f, 0x93, 0x50, 0xe2, 0x65, 0x44, 0x23, 0xde, 0x3d, 0xdb, 0x22, 0xe8, 0x4d, 0x28,
	0xc5, 0x5a, 0x76, 0xf4, 0xe4, 0x03, 0xfd, 0xd8, 0x52, 0xbe, 0xfc, 0x4d, 0x30, 0x5e, 0x2c, 0x9f,
	0x96, 0xd0, 0x1b, 0x50, 0x88, 0x34, 0x69, 0xe8, 0xe2, 0x94, 0xe2, 0x74, 0x1b, 0x58, 0xbe, 0x74,
	0x3a, 0x68, 0xc2, 0x3d, 0x04, 0x34, 0xdd, 0x4e, 0xa1, 0xab, 0x53, 0xda, 0x27, 0x76, 0x77, 0xe5,
	0x6b, 0x0f, 0x84, 0xe5, 0x06, 0xd7, 0xff, 0x28, 0x01, 0xe2, 0xe1, 0x63, 0xb7, 0x42, 0x18, 0xc3,
	0x3b, 0x90, 0x0b, 0xbb, 0x17, 0x34, 0x5d, 0xb6, 0x8f, 0xb5, 0x5b, 0xe5, 0x27, 0x4e, 0x41, 0x4c,
	0x16, 0xa6, 0x43, 0x7e, 0x72, 0xf1, 0xa0, 0x13, 0x34, 0x22, 0xf7, 0x5a, 0xb9, 0x7a, 0x1a, 0x24,
	0x64, 0xad, 0xbf, 0xf8, 0xe9, 0xe7, 0x95, 0xc4, 0x67, 0x9f, 0x57, 0x12, 0x5f, 0x7d, 0x5e, 0x91,
	0xde, 0x39, 0xac, 0x48, 0x1f, 0x1c, 0x56, 0xa4, 0x4f, 0x0e, 0x2b, 0xd2, 0xa7, 0x87, 0x15, 0xe9,
	0x9f, 0x87, 0x15, 0xe9, 0xcb, 0xc3, 0x4a, 0xe2, 0xab, 0xc3, 0x8a, 0xf4, 0xde, 0x17, 0x95, 0xc4,
	0xa7, 0x5f, 0x54, 0x12, 0x9f, 0x7d, 0x51, 0x49, 0xbc, 0x91, 0x0b, 0x39, 0xb7, 0x32, 0xec, 0xff,
	0x96, 0xcf, 0xfe, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x34, 0x2a, 0xf0, 0x31, 0x21, 0x1d, 0x00, 0x00,
}

func (x DataType) String() string {
	s, ok := DataType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x SemanticType) String() string {
	s, ok := SemanticType_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x LifeCycleState) String() string {
	s, ok := LifeCycleState_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ContainerState) String() string {
	s, ok := ContainerState_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x PodPhase) String() string {
	s, ok := PodPhase_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *UInt128) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UInt128)
	if !ok {
		that2, ok := that.(UInt128)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Low != that1.Low {
		return false
	}
	if this.High != that1.High {
		return false
	}
	return true
}
func (this *BooleanColumn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BooleanColumn)
	if !ok {
		that2, ok := that.(BooleanColumn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *Int64Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Int64Column)
	if !ok {
		that2, ok := that.(Int64Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *UInt128Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UInt128Column)
	if !ok {
		that2, ok := that.(UInt128Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if !this.Data[i].Equal(that1.Data[i]) {
			return false
		}
	}
	return true
}
func (this *Float64Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Float64Column)
	if !ok {
		that2, ok := that.(Float64Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *Time64NSColumn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Time64NSColumn)
	if !ok {
		that2, ok := that.(Time64NSColumn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *StringColumn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StringColumn)
	if !ok {
		that2, ok := that.(StringColumn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if !bytes.Equal(this.Data[i], that1.Data[i]) {
			return false
		}
	}
	return true
}
func (this *Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column)
	if !ok {
		that2, ok := that.(Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.ColData == nil {
		if this.ColData != nil {
			return false
		}
	} else if this.ColData == nil {
		return false
	} else if !this.ColData.Equal(that1.ColData) {
		return false
	}
	return true
}
func (this *Column_BooleanData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_BooleanData)
	if !ok {
		that2, ok := that.(Column_BooleanData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.BooleanData.Equal(that1.BooleanData) {
		return false
	}
	return true
}
func (this *Column_Int64Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Int64Data)
	if !ok {
		that2, ok := that.(Column_Int64Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Int64Data.Equal(that1.Int64Data) {
		return false
	}
	return true
}
func (this *Column_Uint128Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Uint128Data)
	if !ok {
		that2, ok := that.(Column_Uint128Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Uint128Data.Equal(that1.Uint128Data) {
		return false
	}
	return true
}
func (this *Column_Time64NsData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Time64NsData)
	if !ok {
		that2, ok := that.(Column_Time64NsData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Time64NsData.Equal(that1.Time64NsData) {
		return false
	}
	return true
}
func (this *Column_Float64Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Float64Data)
	if !ok {
		that2, ok := that.(Column_Float64Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Float64Data.Equal(that1.Float64Data) {
		return false
	}
	return true
}
func (this *Column_StringData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_StringData)
	if !ok {
		that2, ok := that.(Column_StringData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.StringData.Equal(that1.StringData) {
		return false
	}
	return true
}
func (this *RowBatchData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RowBatchData)
	if !ok {
		that2, ok := that.(RowBatchData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TableID != that1.TableID {
		return false
	}
	if len(this.Cols) != len(that1.Cols) {
		return false
	}
	for i := range this.Cols {
		if !this.Cols[i].Equal(that1.Cols[i]) {
			return false
		}
	}
	if this.NumRows != that1.NumRows {
		return false
	}
	if this.Eow != that1.Eow {
		return false
	}
	if this.Eos != that1.Eos {
		return false
	}
	return true
}
func (this *Relation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Relation)
	if !ok {
		that2, ok := that.(Relation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Columns) != len(that1.Columns) {
		return false
	}
	for i := range this.Columns {
		if !this.Columns[i].Equal(that1.Columns[i]) {
			return false
		}
	}
	return true
}
func (this *Relation_ColumnInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Relation_ColumnInfo)
	if !ok {
		that2, ok := that.(Relation_ColumnInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ColumnName != that1.ColumnName {
		return false
	}
	if this.ColumnType != that1.ColumnType {
		return false
	}
	if this.ColumnDesc != that1.ColumnDesc {
		return false
	}
	if this.ColumnSemanticType != that1.ColumnSemanticType {
		return false
	}
	return true
}
func (this *CompilerError) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompilerError)
	if !ok {
		that2, ok := that.(CompilerError)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Line != that1.Line {
		return false
	}
	if this.Column != that1.Column {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *ErrorDetails) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ErrorDetails)
	if !ok {
		that2, ok := that.(ErrorDetails)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.Error == nil {
		if this.Error != nil {
			return false
		}
	} else if this.Error == nil {
		return false
	} else if !this.Error.Equal(that1.Error) {
		return false
	}
	return true
}
func (this *ErrorDetails_CompilerError) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ErrorDetails_CompilerError)
	if !ok {
		that2, ok := that.(ErrorDetails_CompilerError)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.CompilerError.Equal(that1.CompilerError) {
		return false
	}
	return true
}
func (this *Status) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Status)
	if !ok {
		that2, ok := that.(Status)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Code != that1.Code {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if len(this.ErrorDetails) != len(that1.ErrorDetails) {
		return false
	}
	for i := range this.ErrorDetails {
		if !this.ErrorDetails[i].Equal(that1.ErrorDetails[i]) {
			return false
		}
	}
	return true
}
func (this *ScalarValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue)
	if !ok {
		that2, ok := that.(ScalarValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DataType != that1.DataType {
		return false
	}
	if that1.Value == nil {
		if this.Value != nil {
			return false
		}
	} else if this.Value == nil {
		return false
	} else if !this.Value.Equal(that1.Value) {
		return false
	}
	return true
}
func (this *ScalarValue_BoolValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue_BoolValue)
	if !ok {
		that2, ok := that.(ScalarValue_BoolValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.BoolValue != that1.BoolValue {
		return false
	}
	return true
}
func (this *ScalarValue_Int64Value) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue_Int64Value)
	if !ok {
		that2, ok := that.(ScalarValue_Int64Value)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Int64Value != that1.Int64Value {
		return false
	}
	return true
}
func (this *ScalarValue_Float64Value) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue_Float64Value)
	if !ok {
		that2, ok := that.(ScalarValue_Float64Value)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Float64Value != that1.Float64Value {
		return false
	}
	return true
}
func (this *ScalarValue_StringValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue_StringValue)
	if !ok {
		that2, ok := that.(ScalarValue_StringValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StringValue != that1.StringValue {
		return false
	}
	return true
}
func (this *ScalarValue_Time64NsValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue_Time64NsValue)
	if !ok {
		that2, ok := that.(ScalarValue_Time64NsValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Time64NsValue != that1.Time64NsValue {
		return false
	}
	return true
}
func (this *ScalarValue_Uint128Value) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ScalarValue_Uint128Value)
	if !ok {
		that2, ok := that.(ScalarValue_Uint128Value)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Uint128Value.Equal(that1.Uint128Value) {
		return false
	}
	return true
}
func (this *ExecuteScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptRequest)
	if !ok {
		that2, ok := that.(ExecuteScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.QueryStr != that1.QueryStr {
		return false
	}
	if this.ClusterID != that1.ClusterID {
		return false
	}
	if len(this.ExecFuncs) != len(that1.ExecFuncs) {
		return false
	}
	for i := range this.ExecFuncs {
		if !this.ExecFuncs[i].Equal(that1.ExecFuncs[i]) {
			return false
		}
	}
	if this.Mutation != that1.Mutation {
		return false
	}
	if !this.EncryptionOptions.Equal(that1.EncryptionOptions) {
		return false
	}
	if this.QueryID != that1.QueryID {
		return false
	}
	if !this.Configs.Equal(that1.Configs) {
		return false
	}
	if this.QueryName != that1.QueryName {
		return false
	}
	return true
}
func (this *ExecuteScriptRequest_FuncToExecute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptRequest_FuncToExecute)
	if !ok {
		that2, ok := that.(ExecuteScriptRequest_FuncToExecute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.FuncName != that1.FuncName {
		return false
	}
	if len(this.ArgValues) != len(that1.ArgValues) {
		return false
	}
	for i := range this.ArgValues {
		if !this.ArgValues[i].Equal(that1.ArgValues[i]) {
			return false
		}
	}
	if this.OutputTablePrefix != that1.OutputTablePrefix {
		return false
	}
	return true
}
func (this *ExecuteScriptRequest_FuncToExecute_ArgValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptRequest_FuncToExecute_ArgValue)
	if !ok {
		that2, ok := that.(ExecuteScriptRequest_FuncToExecute_ArgValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *ExecuteScriptRequest_EncryptionOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptRequest_EncryptionOptions)
	if !ok {
		that2, ok := that.(ExecuteScriptRequest_EncryptionOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.JwkKey != that1.JwkKey {
		return false
	}
	if this.KeyAlg != that1.KeyAlg {
		return false
	}
	if this.ContentAlg != that1.ContentAlg {
		return false
	}
	if this.CompressionAlg != that1.CompressionAlg {
		return false
	}
	return true
}
func (this *Configs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Configs)
	if !ok {
		that2, ok := that.(Configs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.OTelEndpointConfig.Equal(that1.OTelEndpointConfig) {
		return false
	}
	if !this.PluginConfig.Equal(that1.PluginConfig) {
		return false
	}
	return true
}
func (this *Configs_OTelEndpointConfig) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Configs_OTelEndpointConfig)
	if !ok {
		that2, ok := that.(Configs_OTelEndpointConfig)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.URL != that1.URL {
		return false
	}
	if len(this.Headers) != len(that1.Headers) {
		return false
	}
	for i := range this.Headers {
		if this.Headers[i] != that1.Headers[i] {
			return false
		}
	}
	if this.Insecure != that1.Insecure {
		return false
	}
	if this.Timeout != that1.Timeout {
		return false
	}
	return true
}
func (this *Configs_PluginConfig) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Configs_PluginConfig)
	if !ok {
		that2, ok := that.(Configs_PluginConfig)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StartTimeNs != that1.StartTimeNs {
		return false
	}
	if this.EndTimeNs != that1.EndTimeNs {
		return false
	}
	return true
}
func (this *QueryTimingInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*QueryTimingInfo)
	if !ok {
		that2, ok := that.(QueryTimingInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ExecutionTimeNs != that1.ExecutionTimeNs {
		return false
	}
	if this.CompilationTimeNs != that1.CompilationTimeNs {
		return false
	}
	return true
}
func (this *QueryExecutionStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*QueryExecutionStats)
	if !ok {
		that2, ok := that.(QueryExecutionStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Timing.Equal(that1.Timing) {
		return false
	}
	if this.BytesProcessed != that1.BytesProcessed {
		return false
	}
	if this.RecordsProcessed != that1.RecordsProcessed {
		return false
	}
	return true
}
func (this *QueryMetadata) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*QueryMetadata)
	if !ok {
		that2, ok := that.(QueryMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Relation.Equal(that1.Relation) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	return true
}
func (this *QueryData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*QueryData)
	if !ok {
		that2, ok := that.(QueryData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Batch.Equal(that1.Batch) {
		return false
	}
	if !bytes.Equal(this.EncryptedBatch, that1.EncryptedBatch) {
		return false
	}
	if !this.ExecutionStats.Equal(that1.ExecutionStats) {
		return false
	}
	return true
}
func (this *ExecuteScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptResponse)
	if !ok {
		that2, ok := that.(ExecuteScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if this.QueryID != that1.QueryID {
		return false
	}
	if that1.Result == nil {
		if this.Result != nil {
			return false
		}
	} else if this.Result == nil {
		return false
	} else if !this.Result.Equal(that1.Result) {
		return false
	}
	if !this.MutationInfo.Equal(that1.MutationInfo) {
		return false
	}
	return true
}
func (this *ExecuteScriptResponse_Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptResponse_Data)
	if !ok {
		that2, ok := that.(ExecuteScriptResponse_Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	return true
}
func (this *ExecuteScriptResponse_MetaData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExecuteScriptResponse_MetaData)
	if !ok {
		that2, ok := that.(ExecuteScriptResponse_MetaData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MetaData.Equal(that1.MetaData) {
		return false
	}
	return true
}
func (this *MutationInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MutationInfo)
	if !ok {
		that2, ok := that.(MutationInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if len(this.States) != len(that1.States) {
		return false
	}
	for i := range this.States {
		if !this.States[i].Equal(that1.States[i]) {
			return false
		}
	}
	return true
}
func (this *MutationInfo_MutationState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MutationInfo_MutationState)
	if !ok {
		that2, ok := that.(MutationInfo_MutationState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ID != that1.ID {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	return true
}
func (this *HealthCheckRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HealthCheckRequest)
	if !ok {
		that2, ok := that.(HealthCheckRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ClusterID != that1.ClusterID {
		return false
	}
	return true
}
func (this *HealthCheckResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HealthCheckResponse)
	if !ok {
		that2, ok := that.(HealthCheckResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *GenerateOTelScriptRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GenerateOTelScriptRequest)
	if !ok {
		that2, ok := that.(GenerateOTelScriptRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ClusterID != that1.ClusterID {
		return false
	}
	if this.PxlScript != that1.PxlScript {
		return false
	}
	return true
}
func (this *GenerateOTelScriptResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GenerateOTelScriptResponse)
	if !ok {
		that2, ok := that.(GenerateOTelScriptResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if this.OTelScript != that1.OTelScript {
		return false
	}
	return true
}
func (this *DebugLogRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DebugLogRequest)
	if !ok {
		that2, ok := that.(DebugLogRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ClusterID != that1.ClusterID {
		return false
	}
	if this.PodName != that1.PodName {
		return false
	}
	if this.Previous != that1.Previous {
		return false
	}
	if this.Container != that1.Container {
		return false
	}
	return true
}
func (this *DebugLogResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DebugLogResponse)
	if !ok {
		that2, ok := that.(DebugLogResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Data != that1.Data {
		return false
	}
	return true
}
func (this *ContainerStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ContainerStatus)
	if !ok {
		that2, ok := that.(ContainerStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.ContainerState != that1.ContainerState {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.StartTimestampNS != that1.StartTimestampNS {
		return false
	}
	if this.RestartCount != that1.RestartCount {
		return false
	}
	return true
}
func (this *VizierPodStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*VizierPodStatus)
	if !ok {
		that2, ok := that.(VizierPodStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Phase != that1.Phase {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	if len(this.ContainerStatuses) != len(that1.ContainerStatuses) {
		return false
	}
	for i := range this.ContainerStatuses {
		if !this.ContainerStatuses[i].Equal(that1.ContainerStatuses[i]) {
			return false
		}
	}
	if this.RestartCount != that1.RestartCount {
		return false
	}
	return true
}
func (this *DebugPodsRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DebugPodsRequest)
	if !ok {
		that2, ok := that.(DebugPodsRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ClusterID != that1.ClusterID {
		return false
	}
	return true
}
func (this *DebugPodsResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DebugPodsResponse)
	if !ok {
		that2, ok := that.(DebugPodsResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.DataPlanePods) != len(that1.DataPlanePods) {
		return false
	}
	for i := range this.DataPlanePods {
		if !this.DataPlanePods[i].Equal(that1.DataPlanePods[i]) {
			return false
		}
	}
	if len(this.ControlPlanePods) != len(that1.ControlPlanePods) {
		return false
	}
	for i := range this.ControlPlanePods {
		if !this.ControlPlanePods[i].Equal(that1.ControlPlanePods[i]) {
			return false
		}
	}
	return true
}
func (this *UInt128) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.UInt128{")
	s = append(s, "Low: "+fmt.Sprintf("%#v", this.Low)+",\n")
	s = append(s, "High: "+fmt.Sprintf("%#v", this.High)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BooleanColumn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.BooleanColumn{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Int64Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.Int64Column{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UInt128Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.UInt128Column{")
	if this.Data != nil {
		s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Float64Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.Float64Column{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Time64NSColumn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.Time64NSColumn{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StringColumn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.StringColumn{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&vizierpb.Column{")
	if this.ColData != nil {
		s = append(s, "ColData: "+fmt.Sprintf("%#v", this.ColData)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Column_BooleanData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.Column_BooleanData{` +
		`BooleanData:` + fmt.Sprintf("%#v", this.BooleanData) + `}`}, ", ")
	return s
}
func (this *Column_Int64Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.Column_Int64Data{` +
		`Int64Data:` + fmt.Sprintf("%#v", this.Int64Data) + `}`}, ", ")
	return s
}
func (this *Column_Uint128Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.Column_Uint128Data{` +
		`Uint128Data:` + fmt.Sprintf("%#v", this.Uint128Data) + `}`}, ", ")
	return s
}
func (this *Column_Time64NsData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.Column_Time64NsData{` +
		`Time64NsData:` + fmt.Sprintf("%#v", this.Time64NsData) + `}`}, ", ")
	return s
}
func (this *Column_Float64Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.Column_Float64Data{` +
		`Float64Data:` + fmt.Sprintf("%#v", this.Float64Data) + `}`}, ", ")
	return s
}
func (this *Column_StringData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.Column_StringData{` +
		`StringData:` + fmt.Sprintf("%#v", this.StringData) + `}`}, ", ")
	return s
}
func (this *RowBatchData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&vizierpb.RowBatchData{")
	s = append(s, "TableID: "+fmt.Sprintf("%#v", this.TableID)+",\n")
	if this.Cols != nil {
		s = append(s, "Cols: "+fmt.Sprintf("%#v", this.Cols)+",\n")
	}
	s = append(s, "NumRows: "+fmt.Sprintf("%#v", this.NumRows)+",\n")
	s = append(s, "Eow: "+fmt.Sprintf("%#v", this.Eow)+",\n")
	s = append(s, "Eos: "+fmt.Sprintf("%#v", this.Eos)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Relation) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.Relation{")
	if this.Columns != nil {
		s = append(s, "Columns: "+fmt.Sprintf("%#v", this.Columns)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Relation_ColumnInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&vizierpb.Relation_ColumnInfo{")
	s = append(s, "ColumnName: "+fmt.Sprintf("%#v", this.ColumnName)+",\n")
	s = append(s, "ColumnType: "+fmt.Sprintf("%#v", this.ColumnType)+",\n")
	s = append(s, "ColumnDesc: "+fmt.Sprintf("%#v", this.ColumnDesc)+",\n")
	s = append(s, "ColumnSemanticType: "+fmt.Sprintf("%#v", this.ColumnSemanticType)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CompilerError) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.CompilerError{")
	s = append(s, "Line: "+fmt.Sprintf("%#v", this.Line)+",\n")
	s = append(s, "Column: "+fmt.Sprintf("%#v", this.Column)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ErrorDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.ErrorDetails{")
	if this.Error != nil {
		s = append(s, "Error: "+fmt.Sprintf("%#v", this.Error)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ErrorDetails_CompilerError) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ErrorDetails_CompilerError{` +
		`CompilerError:` + fmt.Sprintf("%#v", this.CompilerError) + `}`}, ", ")
	return s
}
func (this *Status) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.Status{")
	s = append(s, "Code: "+fmt.Sprintf("%#v", this.Code)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	if this.ErrorDetails != nil {
		s = append(s, "ErrorDetails: "+fmt.Sprintf("%#v", this.ErrorDetails)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ScalarValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&vizierpb.ScalarValue{")
	s = append(s, "DataType: "+fmt.Sprintf("%#v", this.DataType)+",\n")
	if this.Value != nil {
		s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ScalarValue_BoolValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ScalarValue_BoolValue{` +
		`BoolValue:` + fmt.Sprintf("%#v", this.BoolValue) + `}`}, ", ")
	return s
}
func (this *ScalarValue_Int64Value) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ScalarValue_Int64Value{` +
		`Int64Value:` + fmt.Sprintf("%#v", this.Int64Value) + `}`}, ", ")
	return s
}
func (this *ScalarValue_Float64Value) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ScalarValue_Float64Value{` +
		`Float64Value:` + fmt.Sprintf("%#v", this.Float64Value) + `}`}, ", ")
	return s
}
func (this *ScalarValue_StringValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ScalarValue_StringValue{` +
		`StringValue:` + fmt.Sprintf("%#v", this.StringValue) + `}`}, ", ")
	return s
}
func (this *ScalarValue_Time64NsValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ScalarValue_Time64NsValue{` +
		`Time64NsValue:` + fmt.Sprintf("%#v", this.Time64NsValue) + `}`}, ", ")
	return s
}
func (this *ScalarValue_Uint128Value) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ScalarValue_Uint128Value{` +
		`Uint128Value:` + fmt.Sprintf("%#v", this.Uint128Value) + `}`}, ", ")
	return s
}
func (this *ExecuteScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&vizierpb.ExecuteScriptRequest{")
	s = append(s, "QueryStr: "+fmt.Sprintf("%#v", this.QueryStr)+",\n")
	s = append(s, "ClusterID: "+fmt.Sprintf("%#v", this.ClusterID)+",\n")
	if this.ExecFuncs != nil {
		s = append(s, "ExecFuncs: "+fmt.Sprintf("%#v", this.ExecFuncs)+",\n")
	}
	s = append(s, "Mutation: "+fmt.Sprintf("%#v", this.Mutation)+",\n")
	if this.EncryptionOptions != nil {
		s = append(s, "EncryptionOptions: "+fmt.Sprintf("%#v", this.EncryptionOptions)+",\n")
	}
	s = append(s, "QueryID: "+fmt.Sprintf("%#v", this.QueryID)+",\n")
	if this.Configs != nil {
		s = append(s, "Configs: "+fmt.Sprintf("%#v", this.Configs)+",\n")
	}
	s = append(s, "QueryName: "+fmt.Sprintf("%#v", this.QueryName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecuteScriptRequest_FuncToExecute) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.ExecuteScriptRequest_FuncToExecute{")
	s = append(s, "FuncName: "+fmt.Sprintf("%#v", this.FuncName)+",\n")
	if this.ArgValues != nil {
		s = append(s, "ArgValues: "+fmt.Sprintf("%#v", this.ArgValues)+",\n")
	}
	s = append(s, "OutputTablePrefix: "+fmt.Sprintf("%#v", this.OutputTablePrefix)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecuteScriptRequest_FuncToExecute_ArgValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.ExecuteScriptRequest_FuncToExecute_ArgValue{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecuteScriptRequest_EncryptionOptions) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&vizierpb.ExecuteScriptRequest_EncryptionOptions{")
	s = append(s, "JwkKey: "+fmt.Sprintf("%#v", this.JwkKey)+",\n")
	s = append(s, "KeyAlg: "+fmt.Sprintf("%#v", this.KeyAlg)+",\n")
	s = append(s, "ContentAlg: "+fmt.Sprintf("%#v", this.ContentAlg)+",\n")
	s = append(s, "CompressionAlg: "+fmt.Sprintf("%#v", this.CompressionAlg)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Configs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.Configs{")
	if this.OTelEndpointConfig != nil {
		s = append(s, "OTelEndpointConfig: "+fmt.Sprintf("%#v", this.OTelEndpointConfig)+",\n")
	}
	if this.PluginConfig != nil {
		s = append(s, "PluginConfig: "+fmt.Sprintf("%#v", this.PluginConfig)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Configs_OTelEndpointConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&vizierpb.Configs_OTelEndpointConfig{")
	s = append(s, "URL: "+fmt.Sprintf("%#v", this.URL)+",\n")
	keysForHeaders := make([]string, 0, len(this.Headers))
	for k, _ := range this.Headers {
		keysForHeaders = append(keysForHeaders, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders)
	mapStringForHeaders := "map[string]string{"
	for _, k := range keysForHeaders {
		mapStringForHeaders += fmt.Sprintf("%#v: %#v,", k, this.Headers[k])
	}
	mapStringForHeaders += "}"
	if this.Headers != nil {
		s = append(s, "Headers: "+mapStringForHeaders+",\n")
	}
	s = append(s, "Insecure: "+fmt.Sprintf("%#v", this.Insecure)+",\n")
	s = append(s, "Timeout: "+fmt.Sprintf("%#v", this.Timeout)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Configs_PluginConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.Configs_PluginConfig{")
	s = append(s, "StartTimeNs: "+fmt.Sprintf("%#v", this.StartTimeNs)+",\n")
	s = append(s, "EndTimeNs: "+fmt.Sprintf("%#v", this.EndTimeNs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *QueryTimingInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.QueryTimingInfo{")
	s = append(s, "ExecutionTimeNs: "+fmt.Sprintf("%#v", this.ExecutionTimeNs)+",\n")
	s = append(s, "CompilationTimeNs: "+fmt.Sprintf("%#v", this.CompilationTimeNs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *QueryExecutionStats) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.QueryExecutionStats{")
	if this.Timing != nil {
		s = append(s, "Timing: "+fmt.Sprintf("%#v", this.Timing)+",\n")
	}
	s = append(s, "BytesProcessed: "+fmt.Sprintf("%#v", this.BytesProcessed)+",\n")
	s = append(s, "RecordsProcessed: "+fmt.Sprintf("%#v", this.RecordsProcessed)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *QueryMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.QueryMetadata{")
	if this.Relation != nil {
		s = append(s, "Relation: "+fmt.Sprintf("%#v", this.Relation)+",\n")
	}
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *QueryData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.QueryData{")
	if this.Batch != nil {
		s = append(s, "Batch: "+fmt.Sprintf("%#v", this.Batch)+",\n")
	}
	s = append(s, "EncryptedBatch: "+fmt.Sprintf("%#v", this.EncryptedBatch)+",\n")
	if this.ExecutionStats != nil {
		s = append(s, "ExecutionStats: "+fmt.Sprintf("%#v", this.ExecutionStats)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecuteScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&vizierpb.ExecuteScriptResponse{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "QueryID: "+fmt.Sprintf("%#v", this.QueryID)+",\n")
	if this.Result != nil {
		s = append(s, "Result: "+fmt.Sprintf("%#v", this.Result)+",\n")
	}
	if this.MutationInfo != nil {
		s = append(s, "MutationInfo: "+fmt.Sprintf("%#v", this.MutationInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExecuteScriptResponse_Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ExecuteScriptResponse_Data{` +
		`Data:` + fmt.Sprintf("%#v", this.Data) + `}`}, ", ")
	return s
}
func (this *ExecuteScriptResponse_MetaData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&vizierpb.ExecuteScriptResponse_MetaData{` +
		`MetaData:` + fmt.Sprintf("%#v", this.MetaData) + `}`}, ", ")
	return s
}
func (this *MutationInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.MutationInfo{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	if this.States != nil {
		s = append(s, "States: "+fmt.Sprintf("%#v", this.States)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MutationInfo_MutationState) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vizierpb.MutationInfo_MutationState{")
	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HealthCheckRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.HealthCheckRequest{")
	s = append(s, "ClusterID: "+fmt.Sprintf("%#v", this.ClusterID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *HealthCheckResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.HealthCheckResponse{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GenerateOTelScriptRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.GenerateOTelScriptRequest{")
	s = append(s, "ClusterID: "+fmt.Sprintf("%#v", this.ClusterID)+",\n")
	s = append(s, "PxlScript: "+fmt.Sprintf("%#v", this.PxlScript)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GenerateOTelScriptResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.GenerateOTelScriptResponse{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	s = append(s, "OTelScript: "+fmt.Sprintf("%#v", this.OTelScript)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DebugLogRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&vizierpb.DebugLogRequest{")
	s = append(s, "ClusterID: "+fmt.Sprintf("%#v", this.ClusterID)+",\n")
	s = append(s, "PodName: "+fmt.Sprintf("%#v", this.PodName)+",\n")
	s = append(s, "Previous: "+fmt.Sprintf("%#v", this.Previous)+",\n")
	s = append(s, "Container: "+fmt.Sprintf("%#v", this.Container)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DebugLogResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.DebugLogResponse{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ContainerStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&vizierpb.ContainerStatus{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "ContainerState: "+fmt.Sprintf("%#v", this.ContainerState)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "StartTimestampNS: "+fmt.Sprintf("%#v", this.StartTimestampNS)+",\n")
	s = append(s, "RestartCount: "+fmt.Sprintf("%#v", this.RestartCount)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VizierPodStatus) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&vizierpb.VizierPodStatus{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Phase: "+fmt.Sprintf("%#v", this.Phase)+",\n")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "Reason: "+fmt.Sprintf("%#v", this.Reason)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	if this.ContainerStatuses != nil {
		s = append(s, "ContainerStatuses: "+fmt.Sprintf("%#v", this.ContainerStatuses)+",\n")
	}
	s = append(s, "RestartCount: "+fmt.Sprintf("%#v", this.RestartCount)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DebugPodsRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vizierpb.DebugPodsRequest{")
	s = append(s, "ClusterID: "+fmt.Sprintf("%#v", this.ClusterID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DebugPodsResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vizierpb.DebugPodsResponse{")
	if this.DataPlanePods != nil {
		s = append(s, "DataPlanePods: "+fmt.Sprintf("%#v", this.DataPlanePods)+",\n")
	}
	if this.ControlPlanePods != nil {
		s = append(s, "ControlPlanePods: "+fmt.Sprintf("%#v", this.ControlPlanePods)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringVizierapi(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// VizierServiceClient is the client API for VizierService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VizierServiceClient interface {
	ExecuteScript(ctx context.Context, in *ExecuteScriptRequest, opts ...grpc.CallOption) (VizierService_ExecuteScriptClient, error)
	HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (VizierService_HealthCheckClient, error)
	GenerateOTelScript(ctx context.Context, in *GenerateOTelScriptRequest, opts ...grpc.CallOption) (*GenerateOTelScriptResponse, error)
}

type vizierServiceClient struct {
	cc *grpc.ClientConn
}

func NewVizierServiceClient(cc *grpc.ClientConn) VizierServiceClient {
	return &vizierServiceClient{cc}
}

func (c *vizierServiceClient) ExecuteScript(ctx context.Context, in *ExecuteScriptRequest, opts ...grpc.CallOption) (VizierService_ExecuteScriptClient, error) {
	stream, err := c.cc.NewStream(ctx, &_VizierService_serviceDesc.Streams[0], "/px.api.vizierpb.VizierService/ExecuteScript", opts...)
	if err != nil {
		return nil, err
	}
	x := &vizierServiceExecuteScriptClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type VizierService_ExecuteScriptClient interface {
	Recv() (*ExecuteScriptResponse, error)
	grpc.ClientStream
}

type vizierServiceExecuteScriptClient struct {
	grpc.ClientStream
}

func (x *vizierServiceExecuteScriptClient) Recv() (*ExecuteScriptResponse, error) {
	m := new(ExecuteScriptResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *vizierServiceClient) HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (VizierService_HealthCheckClient, error) {
	stream, err := c.cc.NewStream(ctx, &_VizierService_serviceDesc.Streams[1], "/px.api.vizierpb.VizierService/HealthCheck", opts...)
	if err != nil {
		return nil, err
	}
	x := &vizierServiceHealthCheckClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type VizierService_HealthCheckClient interface {
	Recv() (*HealthCheckResponse, error)
	grpc.ClientStream
}

type vizierServiceHealthCheckClient struct {
	grpc.ClientStream
}

func (x *vizierServiceHealthCheckClient) Recv() (*HealthCheckResponse, error) {
	m := new(HealthCheckResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *vizierServiceClient) GenerateOTelScript(ctx context.Context, in *GenerateOTelScriptRequest, opts ...grpc.CallOption) (*GenerateOTelScriptResponse, error) {
	out := new(GenerateOTelScriptResponse)
	err := c.cc.Invoke(ctx, "/px.api.vizierpb.VizierService/GenerateOTelScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VizierServiceServer is the server API for VizierService service.
type VizierServiceServer interface {
	ExecuteScript(*ExecuteScriptRequest, VizierService_ExecuteScriptServer) error
	HealthCheck(*HealthCheckRequest, VizierService_HealthCheckServer) error
	GenerateOTelScript(context.Context, *GenerateOTelScriptRequest) (*GenerateOTelScriptResponse, error)
}

// UnimplementedVizierServiceServer can be embedded to have forward compatible implementations.
type UnimplementedVizierServiceServer struct {
}

func (*UnimplementedVizierServiceServer) ExecuteScript(req *ExecuteScriptRequest, srv VizierService_ExecuteScriptServer) error {
	return status.Errorf(codes.Unimplemented, "method ExecuteScript not implemented")
}
func (*UnimplementedVizierServiceServer) HealthCheck(req *HealthCheckRequest, srv VizierService_HealthCheckServer) error {
	return status.Errorf(codes.Unimplemented, "method HealthCheck not implemented")
}
func (*UnimplementedVizierServiceServer) GenerateOTelScript(ctx context.Context, req *GenerateOTelScriptRequest) (*GenerateOTelScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateOTelScript not implemented")
}

func RegisterVizierServiceServer(s *grpc.Server, srv VizierServiceServer) {
	s.RegisterService(&_VizierService_serviceDesc, srv)
}

func _VizierService_ExecuteScript_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ExecuteScriptRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VizierServiceServer).ExecuteScript(m, &vizierServiceExecuteScriptServer{stream})
}

type VizierService_ExecuteScriptServer interface {
	Send(*ExecuteScriptResponse) error
	grpc.ServerStream
}

type vizierServiceExecuteScriptServer struct {
	grpc.ServerStream
}

func (x *vizierServiceExecuteScriptServer) Send(m *ExecuteScriptResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _VizierService_HealthCheck_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(HealthCheckRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VizierServiceServer).HealthCheck(m, &vizierServiceHealthCheckServer{stream})
}

type VizierService_HealthCheckServer interface {
	Send(*HealthCheckResponse) error
	grpc.ServerStream
}

type vizierServiceHealthCheckServer struct {
	grpc.ServerStream
}

func (x *vizierServiceHealthCheckServer) Send(m *HealthCheckResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _VizierService_GenerateOTelScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateOTelScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VizierServiceServer).GenerateOTelScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.api.vizierpb.VizierService/GenerateOTelScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VizierServiceServer).GenerateOTelScript(ctx, req.(*GenerateOTelScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VizierService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.api.vizierpb.VizierService",
	HandlerType: (*VizierServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GenerateOTelScript",
			Handler:    _VizierService_GenerateOTelScript_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ExecuteScript",
			Handler:       _VizierService_ExecuteScript_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "HealthCheck",
			Handler:       _VizierService_HealthCheck_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "src/api/proto/vizierpb/vizierapi.proto",
}

// VizierDebugServiceClient is the client API for VizierDebugService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VizierDebugServiceClient interface {
	DebugLog(ctx context.Context, in *DebugLogRequest, opts ...grpc.CallOption) (VizierDebugService_DebugLogClient, error)
	DebugPods(ctx context.Context, in *DebugPodsRequest, opts ...grpc.CallOption) (VizierDebugService_DebugPodsClient, error)
}

type vizierDebugServiceClient struct {
	cc *grpc.ClientConn
}

func NewVizierDebugServiceClient(cc *grpc.ClientConn) VizierDebugServiceClient {
	return &vizierDebugServiceClient{cc}
}

func (c *vizierDebugServiceClient) DebugLog(ctx context.Context, in *DebugLogRequest, opts ...grpc.CallOption) (VizierDebugService_DebugLogClient, error) {
	stream, err := c.cc.NewStream(ctx, &_VizierDebugService_serviceDesc.Streams[0], "/px.api.vizierpb.VizierDebugService/DebugLog", opts...)
	if err != nil {
		return nil, err
	}
	x := &vizierDebugServiceDebugLogClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type VizierDebugService_DebugLogClient interface {
	Recv() (*DebugLogResponse, error)
	grpc.ClientStream
}

type vizierDebugServiceDebugLogClient struct {
	grpc.ClientStream
}

func (x *vizierDebugServiceDebugLogClient) Recv() (*DebugLogResponse, error) {
	m := new(DebugLogResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *vizierDebugServiceClient) DebugPods(ctx context.Context, in *DebugPodsRequest, opts ...grpc.CallOption) (VizierDebugService_DebugPodsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_VizierDebugService_serviceDesc.Streams[1], "/px.api.vizierpb.VizierDebugService/DebugPods", opts...)
	if err != nil {
		return nil, err
	}
	x := &vizierDebugServiceDebugPodsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type VizierDebugService_DebugPodsClient interface {
	Recv() (*DebugPodsResponse, error)
	grpc.ClientStream
}

type vizierDebugServiceDebugPodsClient struct {
	grpc.ClientStream
}

func (x *vizierDebugServiceDebugPodsClient) Recv() (*DebugPodsResponse, error) {
	m := new(DebugPodsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// VizierDebugServiceServer is the server API for VizierDebugService service.
type VizierDebugServiceServer interface {
	DebugLog(*DebugLogRequest, VizierDebugService_DebugLogServer) error
	DebugPods(*DebugPodsRequest, VizierDebugService_DebugPodsServer) error
}

// UnimplementedVizierDebugServiceServer can be embedded to have forward compatible implementations.
type UnimplementedVizierDebugServiceServer struct {
}

func (*UnimplementedVizierDebugServiceServer) DebugLog(req *DebugLogRequest, srv VizierDebugService_DebugLogServer) error {
	return status.Errorf(codes.Unimplemented, "method DebugLog not implemented")
}
func (*UnimplementedVizierDebugServiceServer) DebugPods(req *DebugPodsRequest, srv VizierDebugService_DebugPodsServer) error {
	return status.Errorf(codes.Unimplemented, "method DebugPods not implemented")
}

func RegisterVizierDebugServiceServer(s *grpc.Server, srv VizierDebugServiceServer) {
	s.RegisterService(&_VizierDebugService_serviceDesc, srv)
}

func _VizierDebugService_DebugLog_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DebugLogRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VizierDebugServiceServer).DebugLog(m, &vizierDebugServiceDebugLogServer{stream})
}

type VizierDebugService_DebugLogServer interface {
	Send(*DebugLogResponse) error
	grpc.ServerStream
}

type vizierDebugServiceDebugLogServer struct {
	grpc.ServerStream
}

func (x *vizierDebugServiceDebugLogServer) Send(m *DebugLogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _VizierDebugService_DebugPods_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DebugPodsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VizierDebugServiceServer).DebugPods(m, &vizierDebugServiceDebugPodsServer{stream})
}

type VizierDebugService_DebugPodsServer interface {
	Send(*DebugPodsResponse) error
	grpc.ServerStream
}

type vizierDebugServiceDebugPodsServer struct {
	grpc.ServerStream
}

func (x *vizierDebugServiceDebugPodsServer) Send(m *DebugPodsResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _VizierDebugService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.api.vizierpb.VizierDebugService",
	HandlerType: (*VizierDebugServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "DebugLog",
			Handler:       _VizierDebugService_DebugLog_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DebugPods",
			Handler:       _VizierDebugService_DebugPods_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "src/api/proto/vizierpb/vizierapi.proto",
}

func (m *UInt128) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UInt128) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UInt128) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.High != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.High))
		i--
		dAtA[i] = 0x10
	}
	if m.Low != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.Low))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BooleanColumn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BooleanColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BooleanColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.Data[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Int64Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Int64Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Int64Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		dAtA2 := make([]byte, len(m.Data)*10)
		var j1 int
		for _, num1 := range m.Data {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintVizierapi(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UInt128Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UInt128Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UInt128Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Data[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Float64Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Float64Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Float64Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			f3 := math.Float64bits(float64(m.Data[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f3))
		}
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Data)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Time64NSColumn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Time64NSColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Time64NSColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		dAtA5 := make([]byte, len(m.Data)*10)
		var j4 int
		for _, num1 := range m.Data {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		i -= j4
		copy(dAtA[i:], dAtA5[:j4])
		i = encodeVarintVizierapi(dAtA, i, uint64(j4))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StringColumn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StringColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StringColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Data[iNdEx])
			copy(dAtA[i:], m.Data[iNdEx])
			i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Data[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ColData != nil {
		{
			size := m.ColData.Size()
			i -= size
			if _, err := m.ColData.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Column_BooleanData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_BooleanData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BooleanData != nil {
		{
			size, err := m.BooleanData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Column_Int64Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Int64Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Int64Data != nil {
		{
			size, err := m.Int64Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Column_Uint128Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Uint128Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Uint128Data != nil {
		{
			size, err := m.Uint128Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *Column_Time64NsData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Time64NsData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Time64NsData != nil {
		{
			size, err := m.Time64NsData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *Column_Float64Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Float64Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Float64Data != nil {
		{
			size, err := m.Float64Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *Column_StringData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_StringData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StringData != nil {
		{
			size, err := m.StringData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *RowBatchData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RowBatchData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RowBatchData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TableID) > 0 {
		i -= len(m.TableID)
		copy(dAtA[i:], m.TableID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.TableID)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Eos {
		i--
		if m.Eos {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Eow {
		i--
		if m.Eow {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.NumRows != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.NumRows))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Cols) > 0 {
		for iNdEx := len(m.Cols) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Cols[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Relation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Relation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Relation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Columns) > 0 {
		for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Columns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Relation_ColumnInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Relation_ColumnInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Relation_ColumnInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ColumnSemanticType != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.ColumnSemanticType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ColumnDesc) > 0 {
		i -= len(m.ColumnDesc)
		copy(dAtA[i:], m.ColumnDesc)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ColumnDesc)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ColumnType != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.ColumnType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ColumnName) > 0 {
		i -= len(m.ColumnName)
		copy(dAtA[i:], m.ColumnName)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ColumnName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CompilerError) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CompilerError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CompilerError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Column != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.Column))
		i--
		dAtA[i] = 0x10
	}
	if m.Line != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.Line))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ErrorDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ErrorDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ErrorDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		{
			size := m.Error.Size()
			i -= size
			if _, err := m.Error.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *ErrorDetails_CompilerError) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ErrorDetails_CompilerError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.CompilerError != nil {
		{
			size, err := m.CompilerError.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Status) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Status) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Status) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ErrorDetails) > 0 {
		for iNdEx := len(m.ErrorDetails) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ErrorDetails[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ScalarValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScalarValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size := m.Value.Size()
			i -= size
			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.DataType != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.DataType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ScalarValue_BoolValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.BoolValue {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *ScalarValue_Int64Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue_Int64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintVizierapi(dAtA, i, uint64(m.Int64Value))
	i--
	dAtA[i] = 0x18
	return len(dAtA) - i, nil
}
func (m *ScalarValue_Float64Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue_Float64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Float64Value))))
	i--
	dAtA[i] = 0x21
	return len(dAtA) - i, nil
}
func (m *ScalarValue_StringValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.StringValue)
	copy(dAtA[i:], m.StringValue)
	i = encodeVarintVizierapi(dAtA, i, uint64(len(m.StringValue)))
	i--
	dAtA[i] = 0x2a
	return len(dAtA) - i, nil
}
func (m *ScalarValue_Time64NsValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue_Time64NsValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintVizierapi(dAtA, i, uint64(m.Time64NsValue))
	i--
	dAtA[i] = 0x30
	return len(dAtA) - i, nil
}
func (m *ScalarValue_Uint128Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScalarValue_Uint128Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Uint128Value != nil {
		{
			size, err := m.Uint128Value.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *ExecuteScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecuteScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.QueryName) > 0 {
		i -= len(m.QueryName)
		copy(dAtA[i:], m.QueryName)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.QueryName)))
		i--
		dAtA[i] = 0x52
	}
	if m.Configs != nil {
		{
			size, err := m.Configs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if len(m.QueryID) > 0 {
		i -= len(m.QueryID)
		copy(dAtA[i:], m.QueryID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.QueryID)))
		i--
		dAtA[i] = 0x3a
	}
	if m.EncryptionOptions != nil {
		{
			size, err := m.EncryptionOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Mutation {
		i--
		if m.Mutation {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.ExecFuncs) > 0 {
		for iNdEx := len(m.ExecFuncs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ExecFuncs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.ClusterID) > 0 {
		i -= len(m.ClusterID)
		copy(dAtA[i:], m.ClusterID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ClusterID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.QueryStr) > 0 {
		i -= len(m.QueryStr)
		copy(dAtA[i:], m.QueryStr)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.QueryStr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ExecuteScriptRequest_FuncToExecute) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecuteScriptRequest_FuncToExecute) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptRequest_FuncToExecute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OutputTablePrefix) > 0 {
		i -= len(m.OutputTablePrefix)
		copy(dAtA[i:], m.OutputTablePrefix)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.OutputTablePrefix)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ArgValues) > 0 {
		for iNdEx := len(m.ArgValues) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ArgValues[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.FuncName) > 0 {
		i -= len(m.FuncName)
		copy(dAtA[i:], m.FuncName)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.FuncName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ExecuteScriptRequest_EncryptionOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecuteScriptRequest_EncryptionOptions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptRequest_EncryptionOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CompressionAlg) > 0 {
		i -= len(m.CompressionAlg)
		copy(dAtA[i:], m.CompressionAlg)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.CompressionAlg)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ContentAlg) > 0 {
		i -= len(m.ContentAlg)
		copy(dAtA[i:], m.ContentAlg)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ContentAlg)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.KeyAlg) > 0 {
		i -= len(m.KeyAlg)
		copy(dAtA[i:], m.KeyAlg)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.KeyAlg)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.JwkKey) > 0 {
		i -= len(m.JwkKey)
		copy(dAtA[i:], m.JwkKey)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.JwkKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Configs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Configs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Configs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PluginConfig != nil {
		{
			size, err := m.PluginConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.OTelEndpointConfig != nil {
		{
			size, err := m.OTelEndpointConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Configs_OTelEndpointConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Configs_OTelEndpointConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Configs_OTelEndpointConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timeout != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x20
	}
	if m.Insecure {
		i--
		if m.Insecure {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Headers) > 0 {
		for k := range m.Headers {
			v := m.Headers[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintVizierapi(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintVizierapi(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintVizierapi(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.URL) > 0 {
		i -= len(m.URL)
		copy(dAtA[i:], m.URL)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.URL)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Configs_PluginConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Configs_PluginConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Configs_PluginConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EndTimeNs != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.EndTimeNs))
		i--
		dAtA[i] = 0x10
	}
	if m.StartTimeNs != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.StartTimeNs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryTimingInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryTimingInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryTimingInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CompilationTimeNs != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.CompilationTimeNs))
		i--
		dAtA[i] = 0x10
	}
	if m.ExecutionTimeNs != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.ExecutionTimeNs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryExecutionStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryExecutionStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryExecutionStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RecordsProcessed != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.RecordsProcessed))
		i--
		dAtA[i] = 0x18
	}
	if m.BytesProcessed != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.BytesProcessed))
		i--
		dAtA[i] = 0x10
	}
	if m.Timing != nil {
		{
			size, err := m.Timing.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueryData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EncryptedBatch) > 0 {
		i -= len(m.EncryptedBatch)
		copy(dAtA[i:], m.EncryptedBatch)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.EncryptedBatch)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ExecutionStats != nil {
		{
			size, err := m.ExecutionStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Batch != nil {
		{
			size, err := m.Batch.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ExecuteScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExecuteScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MutationInfo != nil {
		{
			size, err := m.MutationInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Result != nil {
		{
			size := m.Result.Size()
			i -= size
			if _, err := m.Result.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.QueryID) > 0 {
		i -= len(m.QueryID)
		copy(dAtA[i:], m.QueryID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.QueryID)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ExecuteScriptResponse_Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptResponse_Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *ExecuteScriptResponse_MetaData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExecuteScriptResponse_MetaData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MetaData != nil {
		{
			size, err := m.MetaData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *MutationInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MutationInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MutationInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.States) > 0 {
		for iNdEx := len(m.States) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.States[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MutationInfo_MutationState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MutationInfo_MutationState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MutationInfo_MutationState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if m.State != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HealthCheckRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HealthCheckRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HealthCheckRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ClusterID) > 0 {
		i -= len(m.ClusterID)
		copy(dAtA[i:], m.ClusterID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ClusterID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *HealthCheckResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HealthCheckResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HealthCheckResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GenerateOTelScriptRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GenerateOTelScriptRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenerateOTelScriptRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PxlScript) > 0 {
		i -= len(m.PxlScript)
		copy(dAtA[i:], m.PxlScript)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.PxlScript)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClusterID) > 0 {
		i -= len(m.ClusterID)
		copy(dAtA[i:], m.ClusterID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ClusterID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GenerateOTelScriptResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GenerateOTelScriptResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenerateOTelScriptResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OTelScript) > 0 {
		i -= len(m.OTelScript)
		copy(dAtA[i:], m.OTelScript)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.OTelScript)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintVizierapi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DebugLogRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DebugLogRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DebugLogRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Container) > 0 {
		i -= len(m.Container)
		copy(dAtA[i:], m.Container)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Container)))
		i--
		dAtA[i] = 0x22
	}
	if m.Previous {
		i--
		if m.Previous {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.PodName) > 0 {
		i -= len(m.PodName)
		copy(dAtA[i:], m.PodName)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.PodName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClusterID) > 0 {
		i -= len(m.ClusterID)
		copy(dAtA[i:], m.ClusterID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ClusterID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DebugLogResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DebugLogResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DebugLogResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *ContainerStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ContainerStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContainerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RestartCount != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.RestartCount))
		i--
		dAtA[i] = 0x30
	}
	if m.StartTimestampNS != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.StartTimestampNS))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ContainerState != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.ContainerState))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *VizierPodStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VizierPodStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *VizierPodStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RestartCount != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.RestartCount))
		i--
		dAtA[i] = 0x38
	}
	if len(m.ContainerStatuses) > 0 {
		for iNdEx := len(m.ContainerStatuses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ContainerStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if m.CreatedAt != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Phase != 0 {
		i = encodeVarintVizierapi(dAtA, i, uint64(m.Phase))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DebugPodsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DebugPodsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DebugPodsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ClusterID) > 0 {
		i -= len(m.ClusterID)
		copy(dAtA[i:], m.ClusterID)
		i = encodeVarintVizierapi(dAtA, i, uint64(len(m.ClusterID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DebugPodsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DebugPodsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DebugPodsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ControlPlanePods) > 0 {
		for iNdEx := len(m.ControlPlanePods) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ControlPlanePods[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.DataPlanePods) > 0 {
		for iNdEx := len(m.DataPlanePods) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DataPlanePods[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintVizierapi(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintVizierapi(dAtA []byte, offset int, v uint64) int {
	offset -= sovVizierapi(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *UInt128) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Low != 0 {
		n += 1 + sovVizierapi(uint64(m.Low))
	}
	if m.High != 0 {
		n += 1 + sovVizierapi(uint64(m.High))
	}
	return n
}

func (m *BooleanColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		n += 1 + sovVizierapi(uint64(len(m.Data))) + len(m.Data)*1
	}
	return n
}

func (m *Int64Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		l = 0
		for _, e := range m.Data {
			l += sovVizierapi(uint64(e))
		}
		n += 1 + sovVizierapi(uint64(l)) + l
	}
	return n
}

func (m *UInt128Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		for _, e := range m.Data {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	return n
}

func (m *Float64Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		n += 1 + sovVizierapi(uint64(len(m.Data)*8)) + len(m.Data)*8
	}
	return n
}

func (m *Time64NSColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		l = 0
		for _, e := range m.Data {
			l += sovVizierapi(uint64(e))
		}
		n += 1 + sovVizierapi(uint64(l)) + l
	}
	return n
}

func (m *StringColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		for _, b := range m.Data {
			l = len(b)
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	return n
}

func (m *Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ColData != nil {
		n += m.ColData.Size()
	}
	return n
}

func (m *Column_BooleanData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BooleanData != nil {
		l = m.BooleanData.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *Column_Int64Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Int64Data != nil {
		l = m.Int64Data.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *Column_Uint128Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uint128Data != nil {
		l = m.Uint128Data.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *Column_Time64NsData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Time64NsData != nil {
		l = m.Time64NsData.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *Column_Float64Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Float64Data != nil {
		l = m.Float64Data.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *Column_StringData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StringData != nil {
		l = m.StringData.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *RowBatchData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Cols) > 0 {
		for _, e := range m.Cols {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	if m.NumRows != 0 {
		n += 1 + sovVizierapi(uint64(m.NumRows))
	}
	if m.Eow {
		n += 2
	}
	if m.Eos {
		n += 2
	}
	l = len(m.TableID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *Relation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Columns) > 0 {
		for _, e := range m.Columns {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	return n
}

func (m *Relation_ColumnInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ColumnName)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.ColumnType != 0 {
		n += 1 + sovVizierapi(uint64(m.ColumnType))
	}
	l = len(m.ColumnDesc)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.ColumnSemanticType != 0 {
		n += 1 + sovVizierapi(uint64(m.ColumnSemanticType))
	}
	return n
}

func (m *CompilerError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Line != 0 {
		n += 1 + sovVizierapi(uint64(m.Line))
	}
	if m.Column != 0 {
		n += 1 + sovVizierapi(uint64(m.Column))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ErrorDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		n += m.Error.Size()
	}
	return n
}

func (m *ErrorDetails_CompilerError) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CompilerError != nil {
		l = m.CompilerError.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *Status) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovVizierapi(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if len(m.ErrorDetails) > 0 {
		for _, e := range m.ErrorDetails {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	return n
}

func (m *ScalarValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DataType != 0 {
		n += 1 + sovVizierapi(uint64(m.DataType))
	}
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *ScalarValue_BoolValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *ScalarValue_Int64Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovVizierapi(uint64(m.Int64Value))
	return n
}
func (m *ScalarValue_Float64Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	return n
}
func (m *ScalarValue_StringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StringValue)
	n += 1 + l + sovVizierapi(uint64(l))
	return n
}
func (m *ScalarValue_Time64NsValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovVizierapi(uint64(m.Time64NsValue))
	return n
}
func (m *ScalarValue_Uint128Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uint128Value != nil {
		l = m.Uint128Value.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *ExecuteScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.QueryStr)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.ClusterID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if len(m.ExecFuncs) > 0 {
		for _, e := range m.ExecFuncs {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	if m.Mutation {
		n += 2
	}
	if m.EncryptionOptions != nil {
		l = m.EncryptionOptions.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.QueryID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.Configs != nil {
		l = m.Configs.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.QueryName)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ExecuteScriptRequest_FuncToExecute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FuncName)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if len(m.ArgValues) > 0 {
		for _, e := range m.ArgValues {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	l = len(m.OutputTablePrefix)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ExecuteScriptRequest_EncryptionOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.JwkKey)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.KeyAlg)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.ContentAlg)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.CompressionAlg)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *Configs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OTelEndpointConfig != nil {
		l = m.OTelEndpointConfig.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.PluginConfig != nil {
		l = m.PluginConfig.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *Configs_OTelEndpointConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.URL)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if len(m.Headers) > 0 {
		for k, v := range m.Headers {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovVizierapi(uint64(len(k))) + 1 + len(v) + sovVizierapi(uint64(len(v)))
			n += mapEntrySize + 1 + sovVizierapi(uint64(mapEntrySize))
		}
	}
	if m.Insecure {
		n += 2
	}
	if m.Timeout != 0 {
		n += 1 + sovVizierapi(uint64(m.Timeout))
	}
	return n
}

func (m *Configs_PluginConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartTimeNs != 0 {
		n += 1 + sovVizierapi(uint64(m.StartTimeNs))
	}
	if m.EndTimeNs != 0 {
		n += 1 + sovVizierapi(uint64(m.EndTimeNs))
	}
	return n
}

func (m *QueryTimingInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExecutionTimeNs != 0 {
		n += 1 + sovVizierapi(uint64(m.ExecutionTimeNs))
	}
	if m.CompilationTimeNs != 0 {
		n += 1 + sovVizierapi(uint64(m.CompilationTimeNs))
	}
	return n
}

func (m *QueryExecutionStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timing != nil {
		l = m.Timing.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.BytesProcessed != 0 {
		n += 1 + sovVizierapi(uint64(m.BytesProcessed))
	}
	if m.RecordsProcessed != 0 {
		n += 1 + sovVizierapi(uint64(m.RecordsProcessed))
	}
	return n
}

func (m *QueryMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *QueryData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Batch != nil {
		l = m.Batch.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.ExecutionStats != nil {
		l = m.ExecutionStats.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.EncryptedBatch)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ExecuteScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.QueryID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.Result != nil {
		n += m.Result.Size()
	}
	if m.MutationInfo != nil {
		l = m.MutationInfo.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ExecuteScriptResponse_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *ExecuteScriptResponse_MetaData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MetaData != nil {
		l = m.MetaData.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}
func (m *MutationInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if len(m.States) > 0 {
		for _, e := range m.States {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	return n
}

func (m *MutationInfo_MutationState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovVizierapi(uint64(m.State))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *HealthCheckRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *HealthCheckResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *GenerateOTelScriptRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.PxlScript)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *GenerateOTelScriptResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.OTelScript)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *DebugLogRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.PodName)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.Previous {
		n += 2
	}
	l = len(m.Container)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *DebugLogResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *ContainerStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.ContainerState != 0 {
		n += 1 + sovVizierapi(uint64(m.ContainerState))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.StartTimestampNS != 0 {
		n += 1 + sovVizierapi(uint64(m.StartTimestampNS))
	}
	if m.RestartCount != 0 {
		n += 1 + sovVizierapi(uint64(m.RestartCount))
	}
	return n
}

func (m *VizierPodStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.Phase != 0 {
		n += 1 + sovVizierapi(uint64(m.Phase))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovVizierapi(uint64(m.CreatedAt))
	}
	if len(m.ContainerStatuses) > 0 {
		for _, e := range m.ContainerStatuses {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	if m.RestartCount != 0 {
		n += 1 + sovVizierapi(uint64(m.RestartCount))
	}
	return n
}

func (m *DebugPodsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterID)
	if l > 0 {
		n += 1 + l + sovVizierapi(uint64(l))
	}
	return n
}

func (m *DebugPodsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.DataPlanePods) > 0 {
		for _, e := range m.DataPlanePods {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	if len(m.ControlPlanePods) > 0 {
		for _, e := range m.ControlPlanePods {
			l = e.Size()
			n += 1 + l + sovVizierapi(uint64(l))
		}
	}
	return n
}

func sovVizierapi(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozVizierapi(x uint64) (n int) {
	return sovVizierapi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *UInt128) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UInt128{`,
		`Low:` + fmt.Sprintf("%v", this.Low) + `,`,
		`High:` + fmt.Sprintf("%v", this.High) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BooleanColumn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BooleanColumn{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Int64Column) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Int64Column{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UInt128Column) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForData := "[]*UInt128{"
	for _, f := range this.Data {
		repeatedStringForData += strings.Replace(f.String(), "UInt128", "UInt128", 1) + ","
	}
	repeatedStringForData += "}"
	s := strings.Join([]string{`&UInt128Column{`,
		`Data:` + repeatedStringForData + `,`,
		`}`,
	}, "")
	return s
}
func (this *Float64Column) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Float64Column{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Time64NSColumn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Time64NSColumn{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StringColumn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StringColumn{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column{`,
		`ColData:` + fmt.Sprintf("%v", this.ColData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_BooleanData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_BooleanData{`,
		`BooleanData:` + strings.Replace(fmt.Sprintf("%v", this.BooleanData), "BooleanColumn", "BooleanColumn", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Int64Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Int64Data{`,
		`Int64Data:` + strings.Replace(fmt.Sprintf("%v", this.Int64Data), "Int64Column", "Int64Column", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Uint128Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Uint128Data{`,
		`Uint128Data:` + strings.Replace(fmt.Sprintf("%v", this.Uint128Data), "UInt128Column", "UInt128Column", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Time64NsData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Time64NsData{`,
		`Time64NsData:` + strings.Replace(fmt.Sprintf("%v", this.Time64NsData), "Time64NSColumn", "Time64NSColumn", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Float64Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Float64Data{`,
		`Float64Data:` + strings.Replace(fmt.Sprintf("%v", this.Float64Data), "Float64Column", "Float64Column", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_StringData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_StringData{`,
		`StringData:` + strings.Replace(fmt.Sprintf("%v", this.StringData), "StringColumn", "StringColumn", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RowBatchData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForCols := "[]*Column{"
	for _, f := range this.Cols {
		repeatedStringForCols += strings.Replace(f.String(), "Column", "Column", 1) + ","
	}
	repeatedStringForCols += "}"
	s := strings.Join([]string{`&RowBatchData{`,
		`Cols:` + repeatedStringForCols + `,`,
		`NumRows:` + fmt.Sprintf("%v", this.NumRows) + `,`,
		`Eow:` + fmt.Sprintf("%v", this.Eow) + `,`,
		`Eos:` + fmt.Sprintf("%v", this.Eos) + `,`,
		`TableID:` + fmt.Sprintf("%v", this.TableID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Relation) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForColumns := "[]*Relation_ColumnInfo{"
	for _, f := range this.Columns {
		repeatedStringForColumns += strings.Replace(fmt.Sprintf("%v", f), "Relation_ColumnInfo", "Relation_ColumnInfo", 1) + ","
	}
	repeatedStringForColumns += "}"
	s := strings.Join([]string{`&Relation{`,
		`Columns:` + repeatedStringForColumns + `,`,
		`}`,
	}, "")
	return s
}
func (this *Relation_ColumnInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Relation_ColumnInfo{`,
		`ColumnName:` + fmt.Sprintf("%v", this.ColumnName) + `,`,
		`ColumnType:` + fmt.Sprintf("%v", this.ColumnType) + `,`,
		`ColumnDesc:` + fmt.Sprintf("%v", this.ColumnDesc) + `,`,
		`ColumnSemanticType:` + fmt.Sprintf("%v", this.ColumnSemanticType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompilerError) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompilerError{`,
		`Line:` + fmt.Sprintf("%v", this.Line) + `,`,
		`Column:` + fmt.Sprintf("%v", this.Column) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ErrorDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ErrorDetails{`,
		`Error:` + fmt.Sprintf("%v", this.Error) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ErrorDetails_CompilerError) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ErrorDetails_CompilerError{`,
		`CompilerError:` + strings.Replace(fmt.Sprintf("%v", this.CompilerError), "CompilerError", "CompilerError", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Status) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForErrorDetails := "[]*ErrorDetails{"
	for _, f := range this.ErrorDetails {
		repeatedStringForErrorDetails += strings.Replace(f.String(), "ErrorDetails", "ErrorDetails", 1) + ","
	}
	repeatedStringForErrorDetails += "}"
	s := strings.Join([]string{`&Status{`,
		`Code:` + fmt.Sprintf("%v", this.Code) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`ErrorDetails:` + repeatedStringForErrorDetails + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue{`,
		`DataType:` + fmt.Sprintf("%v", this.DataType) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue_BoolValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue_BoolValue{`,
		`BoolValue:` + fmt.Sprintf("%v", this.BoolValue) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue_Int64Value) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue_Int64Value{`,
		`Int64Value:` + fmt.Sprintf("%v", this.Int64Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue_Float64Value) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue_Float64Value{`,
		`Float64Value:` + fmt.Sprintf("%v", this.Float64Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue_StringValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue_StringValue{`,
		`StringValue:` + fmt.Sprintf("%v", this.StringValue) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue_Time64NsValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue_Time64NsValue{`,
		`Time64NsValue:` + fmt.Sprintf("%v", this.Time64NsValue) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ScalarValue_Uint128Value) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ScalarValue_Uint128Value{`,
		`Uint128Value:` + strings.Replace(fmt.Sprintf("%v", this.Uint128Value), "UInt128", "UInt128", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForExecFuncs := "[]*ExecuteScriptRequest_FuncToExecute{"
	for _, f := range this.ExecFuncs {
		repeatedStringForExecFuncs += strings.Replace(fmt.Sprintf("%v", f), "ExecuteScriptRequest_FuncToExecute", "ExecuteScriptRequest_FuncToExecute", 1) + ","
	}
	repeatedStringForExecFuncs += "}"
	s := strings.Join([]string{`&ExecuteScriptRequest{`,
		`QueryStr:` + fmt.Sprintf("%v", this.QueryStr) + `,`,
		`ClusterID:` + fmt.Sprintf("%v", this.ClusterID) + `,`,
		`ExecFuncs:` + repeatedStringForExecFuncs + `,`,
		`Mutation:` + fmt.Sprintf("%v", this.Mutation) + `,`,
		`EncryptionOptions:` + strings.Replace(fmt.Sprintf("%v", this.EncryptionOptions), "ExecuteScriptRequest_EncryptionOptions", "ExecuteScriptRequest_EncryptionOptions", 1) + `,`,
		`QueryID:` + fmt.Sprintf("%v", this.QueryID) + `,`,
		`Configs:` + strings.Replace(this.Configs.String(), "Configs", "Configs", 1) + `,`,
		`QueryName:` + fmt.Sprintf("%v", this.QueryName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptRequest_FuncToExecute) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgValues := "[]*ExecuteScriptRequest_FuncToExecute_ArgValue{"
	for _, f := range this.ArgValues {
		repeatedStringForArgValues += strings.Replace(fmt.Sprintf("%v", f), "ExecuteScriptRequest_FuncToExecute_ArgValue", "ExecuteScriptRequest_FuncToExecute_ArgValue", 1) + ","
	}
	repeatedStringForArgValues += "}"
	s := strings.Join([]string{`&ExecuteScriptRequest_FuncToExecute{`,
		`FuncName:` + fmt.Sprintf("%v", this.FuncName) + `,`,
		`ArgValues:` + repeatedStringForArgValues + `,`,
		`OutputTablePrefix:` + fmt.Sprintf("%v", this.OutputTablePrefix) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptRequest_FuncToExecute_ArgValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecuteScriptRequest_FuncToExecute_ArgValue{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptRequest_EncryptionOptions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecuteScriptRequest_EncryptionOptions{`,
		`JwkKey:` + fmt.Sprintf("%v", this.JwkKey) + `,`,
		`KeyAlg:` + fmt.Sprintf("%v", this.KeyAlg) + `,`,
		`ContentAlg:` + fmt.Sprintf("%v", this.ContentAlg) + `,`,
		`CompressionAlg:` + fmt.Sprintf("%v", this.CompressionAlg) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Configs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Configs{`,
		`OTelEndpointConfig:` + strings.Replace(fmt.Sprintf("%v", this.OTelEndpointConfig), "Configs_OTelEndpointConfig", "Configs_OTelEndpointConfig", 1) + `,`,
		`PluginConfig:` + strings.Replace(fmt.Sprintf("%v", this.PluginConfig), "Configs_PluginConfig", "Configs_PluginConfig", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Configs_OTelEndpointConfig) String() string {
	if this == nil {
		return "nil"
	}
	keysForHeaders := make([]string, 0, len(this.Headers))
	for k, _ := range this.Headers {
		keysForHeaders = append(keysForHeaders, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders)
	mapStringForHeaders := "map[string]string{"
	for _, k := range keysForHeaders {
		mapStringForHeaders += fmt.Sprintf("%v: %v,", k, this.Headers[k])
	}
	mapStringForHeaders += "}"
	s := strings.Join([]string{`&Configs_OTelEndpointConfig{`,
		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
		`Headers:` + mapStringForHeaders + `,`,
		`Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`,
		`Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Configs_PluginConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Configs_PluginConfig{`,
		`StartTimeNs:` + fmt.Sprintf("%v", this.StartTimeNs) + `,`,
		`EndTimeNs:` + fmt.Sprintf("%v", this.EndTimeNs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryTimingInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryTimingInfo{`,
		`ExecutionTimeNs:` + fmt.Sprintf("%v", this.ExecutionTimeNs) + `,`,
		`CompilationTimeNs:` + fmt.Sprintf("%v", this.CompilationTimeNs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryExecutionStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryExecutionStats{`,
		`Timing:` + strings.Replace(this.Timing.String(), "QueryTimingInfo", "QueryTimingInfo", 1) + `,`,
		`BytesProcessed:` + fmt.Sprintf("%v", this.BytesProcessed) + `,`,
		`RecordsProcessed:` + fmt.Sprintf("%v", this.RecordsProcessed) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryMetadata{`,
		`Relation:` + strings.Replace(this.Relation.String(), "Relation", "Relation", 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueryData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&QueryData{`,
		`Batch:` + strings.Replace(this.Batch.String(), "RowBatchData", "RowBatchData", 1) + `,`,
		`ExecutionStats:` + strings.Replace(this.ExecutionStats.String(), "QueryExecutionStats", "QueryExecutionStats", 1) + `,`,
		`EncryptedBatch:` + fmt.Sprintf("%v", this.EncryptedBatch) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecuteScriptResponse{`,
		`Status:` + strings.Replace(this.Status.String(), "Status", "Status", 1) + `,`,
		`QueryID:` + fmt.Sprintf("%v", this.QueryID) + `,`,
		`Result:` + fmt.Sprintf("%v", this.Result) + `,`,
		`MutationInfo:` + strings.Replace(this.MutationInfo.String(), "MutationInfo", "MutationInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptResponse_Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecuteScriptResponse_Data{`,
		`Data:` + strings.Replace(fmt.Sprintf("%v", this.Data), "QueryData", "QueryData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExecuteScriptResponse_MetaData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExecuteScriptResponse_MetaData{`,
		`MetaData:` + strings.Replace(fmt.Sprintf("%v", this.MetaData), "QueryMetadata", "QueryMetadata", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MutationInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForStates := "[]*MutationInfo_MutationState{"
	for _, f := range this.States {
		repeatedStringForStates += strings.Replace(fmt.Sprintf("%v", f), "MutationInfo_MutationState", "MutationInfo_MutationState", 1) + ","
	}
	repeatedStringForStates += "}"
	s := strings.Join([]string{`&MutationInfo{`,
		`Status:` + strings.Replace(this.Status.String(), "Status", "Status", 1) + `,`,
		`States:` + repeatedStringForStates + `,`,
		`}`,
	}, "")
	return s
}
func (this *MutationInfo_MutationState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MutationInfo_MutationState{`,
		`ID:` + fmt.Sprintf("%v", this.ID) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HealthCheckRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HealthCheckRequest{`,
		`ClusterID:` + fmt.Sprintf("%v", this.ClusterID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HealthCheckResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HealthCheckResponse{`,
		`Status:` + strings.Replace(this.Status.String(), "Status", "Status", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GenerateOTelScriptRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GenerateOTelScriptRequest{`,
		`ClusterID:` + fmt.Sprintf("%v", this.ClusterID) + `,`,
		`PxlScript:` + fmt.Sprintf("%v", this.PxlScript) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GenerateOTelScriptResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GenerateOTelScriptResponse{`,
		`Status:` + strings.Replace(this.Status.String(), "Status", "Status", 1) + `,`,
		`OTelScript:` + fmt.Sprintf("%v", this.OTelScript) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DebugLogRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DebugLogRequest{`,
		`ClusterID:` + fmt.Sprintf("%v", this.ClusterID) + `,`,
		`PodName:` + fmt.Sprintf("%v", this.PodName) + `,`,
		`Previous:` + fmt.Sprintf("%v", this.Previous) + `,`,
		`Container:` + fmt.Sprintf("%v", this.Container) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DebugLogResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DebugLogResponse{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainerStatus) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainerStatus{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ContainerState:` + fmt.Sprintf("%v", this.ContainerState) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`StartTimestampNS:` + fmt.Sprintf("%v", this.StartTimestampNS) + `,`,
		`RestartCount:` + fmt.Sprintf("%v", this.RestartCount) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VizierPodStatus) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForContainerStatuses := "[]*ContainerStatus{"
	for _, f := range this.ContainerStatuses {
		repeatedStringForContainerStatuses += strings.Replace(f.String(), "ContainerStatus", "ContainerStatus", 1) + ","
	}
	repeatedStringForContainerStatuses += "}"
	s := strings.Join([]string{`&VizierPodStatus{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Phase:` + fmt.Sprintf("%v", this.Phase) + `,`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`,
		`ContainerStatuses:` + repeatedStringForContainerStatuses + `,`,
		`RestartCount:` + fmt.Sprintf("%v", this.RestartCount) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DebugPodsRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DebugPodsRequest{`,
		`ClusterID:` + fmt.Sprintf("%v", this.ClusterID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DebugPodsResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForDataPlanePods := "[]*VizierPodStatus{"
	for _, f := range this.DataPlanePods {
		repeatedStringForDataPlanePods += strings.Replace(f.String(), "VizierPodStatus", "VizierPodStatus", 1) + ","
	}
	repeatedStringForDataPlanePods += "}"
	repeatedStringForControlPlanePods := "[]*VizierPodStatus{"
	for _, f := range this.ControlPlanePods {
		repeatedStringForControlPlanePods += strings.Replace(f.String(), "VizierPodStatus", "VizierPodStatus", 1) + ","
	}
	repeatedStringForControlPlanePods += "}"
	s := strings.Join([]string{`&DebugPodsResponse{`,
		`DataPlanePods:` + repeatedStringForDataPlanePods + `,`,
		`ControlPlanePods:` + repeatedStringForControlPlanePods + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringVizierapi(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *UInt128) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UInt128: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UInt128: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Low", wireType)
			}
			m.Low = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Low |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field High", wireType)
			}
			m.High = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.High |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BooleanColumn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BooleanColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BooleanColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Data = append(m.Data, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthVizierapi
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthVizierapi
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierapi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Data = append(m.Data, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Int64Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Int64Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Int64Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Data = append(m.Data, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthVizierapi
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthVizierapi
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierapi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Data = append(m.Data, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UInt128Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UInt128Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UInt128Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data, &UInt128{})
			if err := m.Data[len(m.Data)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Float64Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Float64Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Float64Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Data = append(m.Data, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthVizierapi
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthVizierapi
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Data = append(m.Data, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Time64NSColumn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Time64NSColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Time64NSColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Data = append(m.Data, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthVizierapi
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthVizierapi
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierapi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Data = append(m.Data, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StringColumn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StringColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data, make([]byte, postIndex-iNdEx))
			copy(m.Data[len(m.Data)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BooleanData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BooleanColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_BooleanData{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Int64Column{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Int64Data{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint128Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UInt128Column{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Uint128Data{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time64NsData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Time64NSColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Time64NsData{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Float64Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Float64Column{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Float64Data{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &StringColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_StringData{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RowBatchData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowBatchData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowBatchData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cols", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cols = append(m.Cols, &Column{})
			if err := m.Cols[len(m.Cols)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumRows", wireType)
			}
			m.NumRows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumRows |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eow", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Eow = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eos", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Eos = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TableID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Relation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Columns = append(m.Columns, &Relation_ColumnInfo{})
			if err := m.Columns[len(m.Columns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relation_ColumnInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType)
			}
			m.ColumnType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ColumnType |= DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnDesc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnDesc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnSemanticType", wireType)
			}
			m.ColumnSemanticType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ColumnSemanticType |= SemanticType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompilerError) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CompilerError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompilerError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Line", wireType)
			}
			m.Line = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Line |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType)
			}
			m.Column = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Column |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ErrorDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ErrorDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ErrorDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompilerError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CompilerError{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Error = &ErrorDetails_CompilerError{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Status) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Status: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorDetails = append(m.ErrorDetails, &ErrorDetails{})
			if err := m.ErrorDetails[len(m.ErrorDetails)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScalarValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ScalarValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScalarValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
			}
			m.DataType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataType |= DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Value = &ScalarValue_BoolValue{b}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Value", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = &ScalarValue_Int64Value{v}
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Float64Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = &ScalarValue_Float64Value{float64(math.Float64frombits(v))}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = &ScalarValue_StringValue{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time64NsValue", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = &ScalarValue_Time64NsValue{v}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint128Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UInt128{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &ScalarValue_Uint128Value{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExecuteScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecuteScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryStr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueryStr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecFuncs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExecFuncs = append(m.ExecFuncs, &ExecuteScriptRequest_FuncToExecute{})
			if err := m.ExecFuncs[len(m.ExecFuncs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mutation", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Mutation = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptionOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EncryptionOptions == nil {
				m.EncryptionOptions = &ExecuteScriptRequest_EncryptionOptions{}
			}
			if err := m.EncryptionOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueryID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Configs == nil {
				m.Configs = &Configs{}
			}
			if err := m.Configs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueryName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteScriptRequest_FuncToExecute) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FuncToExecute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FuncToExecute: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FuncName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArgValues", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ArgValues = append(m.ArgValues, &ExecuteScriptRequest_FuncToExecute_ArgValue{})
			if err := m.ArgValues[len(m.ArgValues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputTablePrefix", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutputTablePrefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteScriptRequest_FuncToExecute_ArgValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ArgValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ArgValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteScriptRequest_EncryptionOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EncryptionOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EncryptionOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JwkKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JwkKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyAlg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyAlg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContentAlg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContentAlg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompressionAlg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompressionAlg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Configs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Configs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Configs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OTelEndpointConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OTelEndpointConfig == nil {
				m.OTelEndpointConfig = &Configs_OTelEndpointConfig{}
			}
			if err := m.OTelEndpointConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PluginConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PluginConfig == nil {
				m.PluginConfig = &Configs_PluginConfig{}
			}
			if err := m.PluginConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Configs_OTelEndpointConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OTelEndpointConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OTelEndpointConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Headers == nil {
				m.Headers = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowVizierapi
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierapi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthVizierapi
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthVizierapi
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowVizierapi
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthVizierapi
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthVizierapi
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipVizierapi(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthVizierapi
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Headers[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Insecure = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Configs_PluginConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PluginConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PluginConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeNs", wireType)
			}
			m.StartTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndTimeNs", wireType)
			}
			m.EndTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EndTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryTimingInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryTimingInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryTimingInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionTimeNs", wireType)
			}
			m.ExecutionTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExecutionTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompilationTimeNs", wireType)
			}
			m.CompilationTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompilationTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryExecutionStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryExecutionStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryExecutionStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timing", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timing == nil {
				m.Timing = &QueryTimingInfo{}
			}
			if err := m.Timing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesProcessed", wireType)
			}
			m.BytesProcessed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BytesProcessed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordsProcessed", wireType)
			}
			m.RecordsProcessed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RecordsProcessed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relation == nil {
				m.Relation = &Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Batch == nil {
				m.Batch = &RowBatchData{}
			}
			if err := m.Batch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutionStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExecutionStats == nil {
				m.ExecutionStats = &QueryExecutionStats{}
			}
			if err := m.ExecutionStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedBatch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedBatch = append(m.EncryptedBatch[:0], dAtA[iNdEx:postIndex]...)
			if m.EncryptedBatch == nil {
				m.EncryptedBatch = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExecuteScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecuteScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueryID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &QueryData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Result = &ExecuteScriptResponse_Data{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetaData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &QueryMetadata{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Result = &ExecuteScriptResponse_MetaData{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MutationInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MutationInfo == nil {
				m.MutationInfo = &MutationInfo{}
			}
			if err := m.MutationInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MutationInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MutationInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MutationInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field States", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.States = append(m.States, &MutationInfo_MutationState{})
			if err := m.States[len(m.States)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MutationInfo_MutationState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MutationState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MutationState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= LifeCycleState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HealthCheckRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HealthCheckRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HealthCheckRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HealthCheckResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HealthCheckResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HealthCheckResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GenerateOTelScriptRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GenerateOTelScriptRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenerateOTelScriptRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PxlScript", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PxlScript = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GenerateOTelScriptResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GenerateOTelScriptResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenerateOTelScriptResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OTelScript", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OTelScript = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugLogRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DebugLogRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugLogRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Previous", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Previous = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Container = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugLogResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DebugLogResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugLogResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainerStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ContainerStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerState", wireType)
			}
			m.ContainerState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ContainerState |= ContainerState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimestampNS", wireType)
			}
			m.StartTimestampNS = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimestampNS |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartCount", wireType)
			}
			m.RestartCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RestartCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VizierPodStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VizierPodStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VizierPodStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType)
			}
			m.Phase = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Phase |= PodPhase(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerStatuses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContainerStatuses = append(m.ContainerStatuses, &ContainerStatus{})
			if err := m.ContainerStatuses[len(m.ContainerStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestartCount", wireType)
			}
			m.RestartCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RestartCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugPodsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DebugPodsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugPodsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugPodsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DebugPodsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugPodsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataPlanePods", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataPlanePods = append(m.DataPlanePods, &VizierPodStatus{})
			if err := m.DataPlanePods[len(m.DataPlanePods)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlPlanePods", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthVizierapi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthVizierapi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlPlanePods = append(m.ControlPlanePods, &VizierPodStatus{})
			if err := m.ControlPlanePods[len(m.ControlPlanePods)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipVizierapi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthVizierapi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipVizierapi(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowVizierapi
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowVizierapi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthVizierapi
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupVizierapi
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthVizierapi
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthVizierapi        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowVizierapi          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupVizierapi = fmt.Errorf("proto: unexpected end of group")
)
